/*
 * # Semantic UI - 2.2.10
 * https://github.com/Semantic-Org/Semantic-UI
 * http://www.semantic-ui.com/
 *
 * Copyright 2014 Contributors
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */
/*!
 * # Semantic UI 2.2.10 - Site
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  $.site = $.fn.site = function (parameters) {
    var
        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        settings = ( $.isPlainObject(parameters) )
            ? $.extend(true, {}, $.site.settings, parameters)
            : $.extend({}, $.site.settings),

        namespace = settings.namespace,
        error = settings.error,

        eventNamespace = '.' + namespace,
        moduleNamespace = 'module-' + namespace,

        $document = $(document),
        $module = $document,
        element = this,
        instance = $module.data(moduleNamespace),

        module,
        returnedValue
    ;
    module = {

      initialize: function () {
        module.instantiate();
      },

      instantiate: function () {
        module.verbose('Storing instance of site', module);
        instance = module;
        $module
        .data(moduleNamespace, module)
        ;
      },

      normalize: function () {
        module.fix.console();
        module.fix.requestAnimationFrame();
      },

      fix: {
        console: function () {
          module.debug('Normalizing window.console');
          if (console === undefined || console.log === undefined) {
            module.verbose('Console not available, normalizing events');
            module.disable.console();
          }
          if (typeof console.group == 'undefined' || typeof console.groupEnd
              == 'undefined' || typeof console.groupCollapsed == 'undefined') {
            module.verbose('Console group not available, normalizing events');
            window.console.group = function () {
            };
            window.console.groupEnd = function () {
            };
            window.console.groupCollapsed = function () {
            };
          }
          if (typeof console.markTimeline == 'undefined') {
            module.verbose('Mark timeline not available, normalizing events');
            window.console.markTimeline = function () {
            };
          }
        },
        consoleClear: function () {
          module.debug('Disabling programmatic console clearing');
          window.console.clear = function () {
          };
        },
        requestAnimationFrame: function () {
          module.debug('Normalizing requestAnimationFrame');
          if (window.requestAnimationFrame === undefined) {
            module.debug(
                'RequestAnimationFrame not available, normalizing event');
            window.requestAnimationFrame = window.requestAnimationFrame
                || window.mozRequestAnimationFrame
                || window.webkitRequestAnimationFrame
                || window.msRequestAnimationFrame
                || function (callback) {
                  setTimeout(callback, 0);
                }
            ;
          }
        }
      },

      moduleExists: function (name) {
        return ($.fn[name] !== undefined && $.fn[name].settings !== undefined);
      },

      enabled: {
        modules: function (modules) {
          var
              enabledModules = []
          ;
          modules = modules || settings.modules;
          $.each(modules, function (index, name) {
            if (module.moduleExists(name)) {
              enabledModules.push(name);
            }
          });
          return enabledModules;
        }
      },

      disabled: {
        modules: function (modules) {
          var
              disabledModules = []
          ;
          modules = modules || settings.modules;
          $.each(modules, function (index, name) {
            if (!module.moduleExists(name)) {
              disabledModules.push(name);
            }
          });
          return disabledModules;
        }
      },

      change: {
        setting: function (setting, value, modules, modifyExisting) {
          modules = (typeof modules === 'string')
              ? (modules === 'all')
                  ? settings.modules
                  : [modules]
              : modules || settings.modules
          ;
          modifyExisting = (modifyExisting !== undefined)
              ? modifyExisting
              : true
          ;
          $.each(modules, function (index, name) {
            var
                namespace = (module.moduleExists(name))
                    ? $.fn[name].settings.namespace || false
                    : true,
                $existingModules
            ;
            if (module.moduleExists(name)) {
              module.verbose('Changing default setting', setting, value, name);
              $.fn[name].settings[setting] = value;
              if (modifyExisting && namespace) {
                $existingModules = $(':data(module-' + namespace + ')');
                if ($existingModules.length > 0) {
                  module.verbose('Modifying existing settings',
                      $existingModules);
                  $existingModules[name]('setting', setting, value);
                }
              }
            }
          });
        },
        settings: function (newSettings, modules, modifyExisting) {
          modules = (typeof modules === 'string')
              ? [modules]
              : modules || settings.modules
          ;
          modifyExisting = (modifyExisting !== undefined)
              ? modifyExisting
              : true
          ;
          $.each(modules, function (index, name) {
            var
                $existingModules
            ;
            if (module.moduleExists(name)) {
              module.verbose('Changing default setting', newSettings, name);
              $.extend(true, $.fn[name].settings, newSettings);
              if (modifyExisting && namespace) {
                $existingModules = $(':data(module-' + namespace + ')');
                if ($existingModules.length > 0) {
                  module.verbose('Modifying existing settings',
                      $existingModules);
                  $existingModules[name]('setting', newSettings);
                }
              }
            }
          });
        }
      },

      enable: {
        console: function () {
          module.console(true);
        },
        debug: function (modules, modifyExisting) {
          modules = modules || settings.modules;
          module.debug('Enabling debug for modules', modules);
          module.change.setting('debug', true, modules, modifyExisting);
        },
        verbose: function (modules, modifyExisting) {
          modules = modules || settings.modules;
          module.debug('Enabling verbose debug for modules', modules);
          module.change.setting('verbose', true, modules, modifyExisting);
        }
      },
      disable: {
        console: function () {
          module.console(false);
        },
        debug: function (modules, modifyExisting) {
          modules = modules || settings.modules;
          module.debug('Disabling debug for modules', modules);
          module.change.setting('debug', false, modules, modifyExisting);
        },
        verbose: function (modules, modifyExisting) {
          modules = modules || settings.modules;
          module.debug('Disabling verbose debug for modules', modules);
          module.change.setting('verbose', false, modules, modifyExisting);
        }
      },

      console: function (enable) {
        if (enable) {
          if (instance.cache.console === undefined) {
            module.error(error.console);
            return;
          }
          module.debug('Restoring console function');
          window.console = instance.cache.console;
        }
        else {
          module.debug('Disabling console function');
          instance.cache.console = window.console;
          window.console = {
            clear: function () {
            },
            error: function () {
            },
            group: function () {
            },
            groupCollapsed: function () {
            },
            groupEnd: function () {
            },
            info: function () {
            },
            log: function () {
            },
            markTimeline: function () {
            },
            warn: function () {
            }
          };
        }
      },

      destroy: function () {
        module.verbose('Destroying previous site for', $module);
        $module
        .removeData(moduleNamespace)
        ;
      },

      cache: {},

      setting: function (name, value) {
        if ($.isPlainObject(name)) {
          $.extend(true, settings, name);
        }
        else if (value !== undefined) {
          settings[name] = value;
        }
        else {
          return settings[name];
        }
      },
      internal: function (name, value) {
        if ($.isPlainObject(name)) {
          $.extend(true, module, name);
        }
        else if (value !== undefined) {
          module[name] = value;
        }
        else {
          return module[name];
        }
      },
      debug: function () {
        if (settings.debug) {
          if (settings.performance) {
            module.performance.log(arguments);
          }
          else {
            module.debug = Function.prototype.bind.call(console.info, console,
                settings.name + ':');
            module.debug.apply(console, arguments);
          }
        }
      },
      verbose: function () {
        if (settings.verbose && settings.debug) {
          if (settings.performance) {
            module.performance.log(arguments);
          }
          else {
            module.verbose = Function.prototype.bind.call(console.info, console,
                settings.name + ':');
            module.verbose.apply(console, arguments);
          }
        }
      },
      error: function () {
        module.error = Function.prototype.bind.call(console.error, console,
            settings.name + ':');
        module.error.apply(console, arguments);
      },
      performance: {
        log: function (message) {
          var
              currentTime,
              executionTime,
              previousTime
          ;
          if (settings.performance) {
            currentTime = new Date().getTime();
            previousTime = time || currentTime;
            executionTime = currentTime - previousTime;
            time = currentTime;
            performance.push({
              'Element': element,
              'Name': message[0],
              'Arguments': [].slice.call(message, 1) || '',
              'Execution Time': executionTime
            });
          }
          clearTimeout(module.performance.timer);
          module.performance.timer = setTimeout(module.performance.display,
              500);
        },
        display: function () {
          var
              title = settings.name + ':',
              totalTime = 0
          ;
          time = false;
          clearTimeout(module.performance.timer);
          $.each(performance, function (index, data) {
            totalTime += data['Execution Time'];
          });
          title += ' ' + totalTime + 'ms';
          if ((console.group !== undefined || console.table !== undefined)
              && performance.length > 0) {
            console.groupCollapsed(title);
            if (console.table) {
              console.table(performance);
            }
            else {
              $.each(performance, function (index, data) {
                console.log(
                    data['Name'] + ': ' + data['Execution Time'] + 'ms');
              });
            }
            console.groupEnd();
          }
          performance = [];
        }
      },
      invoke: function (query, passedArguments, context) {
        var
            object = instance,
            maxDepth,
            found,
            response
        ;
        passedArguments = passedArguments || queryArguments;
        context = element || context;
        if (typeof query == 'string' && object !== undefined) {
          query = query.split(/[\. ]/);
          maxDepth = query.length - 1;
          $.each(query, function (depth, value) {
            var camelCaseValue = (depth != maxDepth)
                ? value + query[depth + 1].charAt(0).toUpperCase() + query[depth
                + 1].slice(1)
                : query
            ;
            if ($.isPlainObject(object[camelCaseValue]) && (depth
                != maxDepth)) {
              object = object[camelCaseValue];
            }
            else if (object[camelCaseValue] !== undefined) {
              found = object[camelCaseValue];
              return false;
            }
            else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
              object = object[value];
            }
            else if (object[value] !== undefined) {
              found = object[value];
              return false;
            }
            else {
              module.error(error.method, query);
              return false;
            }
          });
        }
        if ($.isFunction(found)) {
          response = found.apply(context, passedArguments);
        }
        else if (found !== undefined) {
          response = found;
        }
        if ($.isArray(returnedValue)) {
          returnedValue.push(response);
        }
        else if (returnedValue !== undefined) {
          returnedValue = [returnedValue, response];
        }
        else if (response !== undefined) {
          returnedValue = response;
        }
        return found;
      }
    };

    if (methodInvoked) {
      if (instance === undefined) {
        module.initialize();
      }
      module.invoke(query);
    }
    else {
      if (instance !== undefined) {
        module.destroy();
      }
      module.initialize();
    }
    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.site.settings = {

    name: 'Site',
    namespace: 'site',

    error: {
      console: 'Console cannot be restored, most likely it was overwritten outside of module',
      method: 'The method you called is not defined.'
    },

    debug: false,
    verbose: false,
    performance: true,

    modules: [
      'accordion',
      'api',
      'checkbox',
      'dimmer',
      'dropdown',
      'embed',
      'form',
      'modal',
      'nag',
      'popup',
      'rating',
      'shape',
      'sidebar',
      'state',
      'sticky',
      'tab',
      'transition',
      'visit',
      'visibility'
    ],

    siteNamespace: 'site',
    namespaceStub: {
      cache: {},
      config: {},
      sections: {},
      section: {},
      utilities: {}
    }

  };

// allows for selection of elements with data attributes
  $.extend($.expr[":"], {
    data: ($.expr.createPseudo)
        ? $.expr.createPseudo(function (dataName) {
          return function (elem) {
            return !!$.data(elem, dataName);
          };
        })
        : function (elem, i, match) {
          // support: jQuery < 1.8
          return !!$.data(elem, match[3]);
        }
  });

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Form Validation
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.form = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        legacyParameters = arguments[1],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;
    $allModules
    .each(function () {
      var
          $module = $(this),
          element = this,

          formErrors = [],
          keyHeldDown = false,

          // set at run-time
          $field,
          $group,
          $message,
          $prompt,
          $submit,
          $clear,
          $reset,

          settings,
          validation,

          metadata,
          selector,
          className,
          regExp,
          error,

          namespace,
          moduleNamespace,
          eventNamespace,

          instance,
          module
      ;

      module = {

        initialize: function () {

          // settings grabbed at run time
          module.get.settings();
          if (methodInvoked) {
            if (instance === undefined) {
              module.instantiate();
            }
            module.invoke(query);
          }
          else {
            if (instance !== undefined) {
              instance.invoke('destroy');
            }
            module.verbose('Initializing form validation', $module, settings);
            module.bindEvents();
            module.set.defaults();
            module.instantiate();
          }
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous module', instance);
          module.removeEvents();
          $module
          .removeData(moduleNamespace)
          ;
        },

        refresh: function () {
          module.verbose('Refreshing selector cache');
          $field = $module.find(selector.field);
          $group = $module.find(selector.group);
          $message = $module.find(selector.message);
          $prompt = $module.find(selector.prompt);

          $submit = $module.find(selector.submit);
          $clear = $module.find(selector.clear);
          $reset = $module.find(selector.reset);
        },

        submit: function () {
          module.verbose('Submitting form', $module);
          $module
          .submit()
          ;
        },

        attachEvents: function (selector, action) {
          action = action || 'submit';
          $(selector)
          .on('click' + eventNamespace, function (event) {
            module[action]();
            event.preventDefault();
          })
          ;
        },

        bindEvents: function () {
          module.verbose('Attaching form events');
          $module
          .on('submit' + eventNamespace, module.validate.form)
          .on('blur' + eventNamespace, selector.field, module.event.field.blur)
          .on('click' + eventNamespace, selector.submit, module.submit)
          .on('click' + eventNamespace, selector.reset, module.reset)
          .on('click' + eventNamespace, selector.clear, module.clear)
          ;
          if (settings.keyboardShortcuts) {
            $module
            .on('keydown' + eventNamespace, selector.field,
                module.event.field.keydown)
            ;
          }
          $field
          .each(function () {
            var
                $input = $(this),
                type = $input.prop('type'),
                inputEvent = module.get.changeEvent(type, $input)
            ;
            $(this)
            .on(inputEvent + eventNamespace, module.event.field.change)
            ;
          })
          ;
        },

        clear: function () {
          $field
          .each(function () {
            var
                $field = $(this),
                $element = $field.parent(),
                $fieldGroup = $field.closest($group),
                $prompt = $fieldGroup.find(selector.prompt),
                defaultValue = $field.data(metadata.defaultValue) || '',
                isCheckbox = $element.is(selector.uiCheckbox),
                isDropdown = $element.is(selector.uiDropdown),
                isErrored = $fieldGroup.hasClass(className.error)
            ;
            if (isErrored) {
              module.verbose('Resetting error on field', $fieldGroup);
              $fieldGroup.removeClass(className.error);
              $prompt.remove();
            }
            if (isDropdown) {
              module.verbose('Resetting dropdown value', $element,
                  defaultValue);
              $element.dropdown('clear');
            }
            else if (isCheckbox) {
              $field.prop('checked', false);
            }
            else {
              module.verbose('Resetting field value', $field, defaultValue);
              $field.val('');
            }
          })
          ;
        },

        reset: function () {
          $field
          .each(function () {
            var
                $field = $(this),
                $element = $field.parent(),
                $fieldGroup = $field.closest($group),
                $prompt = $fieldGroup.find(selector.prompt),
                defaultValue = $field.data(metadata.defaultValue),
                isCheckbox = $element.is(selector.uiCheckbox),
                isDropdown = $element.is(selector.uiDropdown),
                isErrored = $fieldGroup.hasClass(className.error)
            ;
            if (defaultValue === undefined) {
              return;
            }
            if (isErrored) {
              module.verbose('Resetting error on field', $fieldGroup);
              $fieldGroup.removeClass(className.error);
              $prompt.remove();
            }
            if (isDropdown) {
              module.verbose('Resetting dropdown value', $element,
                  defaultValue);
              $element.dropdown('restore defaults');
            }
            else if (isCheckbox) {
              module.verbose('Resetting checkbox value', $element,
                  defaultValue);
              $field.prop('checked', defaultValue);
            }
            else {
              module.verbose('Resetting field value', $field, defaultValue);
              $field.val(defaultValue);
            }
          })
          ;
        },

        determine: {
          isValid: function () {
            var
                allValid = true
            ;
            $.each(validation, function (fieldName, field) {
              if (!( module.validate.field(field, fieldName, true) )) {
                allValid = false;
              }
            });
            return allValid;
          }
        },

        is: {
          bracketedRule: function (rule) {
            return (rule.type && rule.type.match(settings.regExp.bracket));
          },
          empty: function ($field) {
            if (!$field || $field.length === 0) {
              return true;
            }
            else if ($field.is('input[type="checkbox"]')) {
              return !$field.is(':checked');
            }
            else {
              return module.is.blank($field);
            }
          },
          blank: function ($field) {
            return $.trim($field.val()) === '';
          },
          valid: function (field) {
            var
                allValid = true
            ;
            if (field) {
              module.verbose('Checking if field is valid', field);
              return module.validate.field(validation[field], field, false);
            }
            else {
              module.verbose('Checking if form is valid');
              $.each(validation, function (fieldName, field) {
                if (!module.is.valid(fieldName)) {
                  allValid = false;
                }
              });
              return allValid;
            }
          }
        },

        removeEvents: function () {
          $module
          .off(eventNamespace)
          ;
          $field
          .off(eventNamespace)
          ;
          $submit
          .off(eventNamespace)
          ;
          $field
          .off(eventNamespace)
          ;
        },

        event: {
          field: {
            keydown: function (event) {
              var
                  $field = $(this),
                  key = event.which,
                  isInput = $field.is(selector.input),
                  isCheckbox = $field.is(selector.checkbox),
                  isInDropdown = ($field.closest(selector.uiDropdown).length
                  > 0),
                  keyCode = {
                    enter: 13,
                    escape: 27
                  }
              ;
              if (key == keyCode.escape) {
                module.verbose('Escape key pressed blurring field');
                $field
                .blur()
                ;
              }
              if (!event.ctrlKey && key == keyCode.enter && isInput
                  && !isInDropdown && !isCheckbox) {
                if (!keyHeldDown) {
                  $field
                  .one('keyup' + eventNamespace, module.event.field.keyup)
                  ;
                  module.submit();
                  module.debug('Enter pressed on input submitting form');
                }
                keyHeldDown = true;
              }
            },
            keyup: function () {
              keyHeldDown = false;
            },
            blur: function (event) {
              var
                  $field = $(this),
                  $fieldGroup = $field.closest($group),
                  validationRules = module.get.validation($field)
              ;
              if ($fieldGroup.hasClass(className.error)) {
                module.debug('Revalidating field', $field, validationRules);
                if (validationRules) {
                  module.validate.field(validationRules);
                }
              }
              else if (settings.on == 'blur' || settings.on == 'change') {
                if (validationRules) {
                  module.validate.field(validationRules);
                }
              }
            },
            change: function (event) {
              var
                  $field = $(this),
                  $fieldGroup = $field.closest($group),
                  validationRules = module.get.validation($field)
              ;
              if (validationRules && (settings.on == 'change'
                  || ( $fieldGroup.hasClass(className.error)
                  && settings.revalidate) )) {
                clearTimeout(module.timer);
                module.timer = setTimeout(function () {
                  module.debug('Revalidating field', $field,
                      module.get.validation($field));
                  module.validate.field(validationRules);
                }, settings.delay);
              }
            }
          }

        },

        get: {
          ancillaryValue: function (rule) {
            if (!rule.type || (!rule.value && !module.is.bracketedRule(rule))) {
              return false;
            }
            return (rule.value !== undefined)
                ? rule.value
                : rule.type.match(settings.regExp.bracket)[1] + ''
                ;
          },
          ruleName: function (rule) {
            if (module.is.bracketedRule(rule)) {
              return rule.type.replace(
                  rule.type.match(settings.regExp.bracket)[0], '');
            }
            return rule.type;
          },
          changeEvent: function (type, $input) {
            if (type == 'checkbox' || type == 'radio' || type == 'hidden'
                || $input.is('select')) {
              return 'change';
            }
            else {
              return module.get.inputEvent();
            }
          },
          inputEvent: function () {
            return (document.createElement('input').oninput !== undefined)
                ? 'input'
                : (document.createElement('input').onpropertychange
                !== undefined)
                    ? 'propertychange'
                    : 'keyup'
                ;
          },
          prompt: function (rule, field) {
            var
                ruleName = module.get.ruleName(rule),
                ancillary = module.get.ancillaryValue(rule),
                prompt = rule.prompt || settings.prompt[ruleName]
                    || settings.text.unspecifiedRule,
                requiresValue = (prompt.search('{value}') !== -1),
                requiresName = (prompt.search('{name}') !== -1),
                $label,
                $field,
                name
            ;
            if (requiresName || requiresValue) {
              $field = module.get.field(field.identifier);
            }
            if (requiresValue) {
              prompt = prompt.replace('{value}', $field.val());
            }
            if (requiresName) {
              $label = $field.closest(selector.group).find('label').eq(0);
              name = ($label.length == 1)
                  ? $label.text()
                  : $field.prop('placeholder') || settings.text.unspecifiedField
              ;
              prompt = prompt.replace('{name}', name);
            }
            prompt = prompt.replace('{identifier}', field.identifier);
            prompt = prompt.replace('{ruleValue}', ancillary);
            if (!rule.prompt) {
              module.verbose('Using default validation prompt for type', prompt,
                  ruleName);
            }
            return prompt;
          },
          settings: function () {
            if ($.isPlainObject(parameters)) {
              var
                  keys = Object.keys(parameters),
                  isLegacySettings = (keys.length > 0)
                      ? (parameters[keys[0]].identifier !== undefined
                      && parameters[keys[0]].rules !== undefined)
                      : false,
                  ruleKeys
              ;
              if (isLegacySettings) {
                // 1.x (ducktyped)
                settings = $.extend(true, {}, $.fn.form.settings,
                    legacyParameters);
                validation = $.extend({}, $.fn.form.settings.defaults,
                    parameters);
                module.error(settings.error.oldSyntax, element);
                module.verbose('Extending settings from legacy parameters',
                    validation, settings);
              }
              else {
                // 2.x
                if (parameters.fields) {
                  ruleKeys = Object.keys(parameters.fields);
                  if (typeof parameters.fields[ruleKeys[0]] == 'string'
                      || $.isArray(parameters.fields[ruleKeys[0]])) {
                    $.each(parameters.fields, function (name, rules) {
                      if (typeof rules == 'string') {
                        rules = [rules];
                      }
                      parameters.fields[name] = {
                        rules: []
                      };
                      $.each(rules, function (index, rule) {
                        parameters.fields[name].rules.push({type: rule});
                      });
                    });
                  }
                }

                settings = $.extend(true, {}, $.fn.form.settings, parameters);
                validation = $.extend({}, $.fn.form.settings.defaults,
                    settings.fields);
                module.verbose('Extending settings', validation, settings);
              }
            }
            else {
              settings = $.fn.form.settings;
              validation = $.fn.form.settings.defaults;
              module.verbose('Using default form validation', validation,
                  settings);
            }

            // shorthand
            namespace = settings.namespace;
            metadata = settings.metadata;
            selector = settings.selector;
            className = settings.className;
            regExp = settings.regExp;
            error = settings.error;
            moduleNamespace = 'module-' + namespace;
            eventNamespace = '.' + namespace;

            // grab instance
            instance = $module.data(moduleNamespace);

            // refresh selector cache
            module.refresh();
          },
          field: function (identifier) {
            module.verbose('Finding field with identifier', identifier);
            identifier = module.escape.string(identifier);
            if ($field.filter('#' + identifier).length > 0) {
              return $field.filter('#' + identifier);
            }
            else if ($field.filter('[name="' + identifier + '"]').length > 0) {
              return $field.filter('[name="' + identifier + '"]');
            }
            else if ($field.filter('[name="' + identifier + '[]"]').length
                > 0) {
              return $field.filter('[name="' + identifier + '[]"]');
            }
            else if ($field.filter(
                    '[data-' + metadata.validate + '="' + identifier
                    + '"]').length > 0) {
              return $field.filter(
                  '[data-' + metadata.validate + '="' + identifier + '"]');
            }
            return $('<input/>');
          },
          fields: function (fields) {
            var
                $fields = $()
            ;
            $.each(fields, function (index, name) {
              $fields = $fields.add(module.get.field(name));
            });
            return $fields;
          },
          validation: function ($field) {
            var
                fieldValidation,
                identifier
            ;
            if (!validation) {
              return false;
            }
            $.each(validation, function (fieldName, field) {
              identifier = field.identifier || fieldName;
              if (module.get.field(identifier)[0] == $field[0]) {
                field.identifier = identifier;
                fieldValidation = field;
              }
            });
            return fieldValidation || false;
          },
          value: function (field) {
            var
                fields = [],
                results
            ;
            fields.push(field);
            results = module.get.values.call(element, fields);
            return results[field];
          },
          values: function (fields) {
            var
                $fields = $.isArray(fields)
                    ? module.get.fields(fields)
                    : $field,
                values = {}
            ;
            $fields.each(function (index, field) {
              var
                  $field = $(field),
                  type = $field.prop('type'),
                  name = $field.prop('name'),
                  value = $field.val(),
                  isCheckbox = $field.is(selector.checkbox),
                  isRadio = $field.is(selector.radio),
                  isMultiple = (name.indexOf('[]') !== -1),
                  isChecked = (isCheckbox)
                      ? $field.is(':checked')
                      : false
              ;
              if (name) {
                if (isMultiple) {
                  name = name.replace('[]', '');
                  if (!values[name]) {
                    values[name] = [];
                  }
                  if (isCheckbox) {
                    if (isChecked) {
                      values[name].push(value || true);
                    }
                    else {
                      values[name].push(false);
                    }
                  }
                  else {
                    values[name].push(value);
                  }
                }
                else {
                  if (isRadio) {
                    if (isChecked) {
                      values[name] = value;
                    }
                  }
                  else if (isCheckbox) {
                    if (isChecked) {
                      values[name] = value || true;
                    }
                    else {
                      values[name] = false;
                    }
                  }
                  else {
                    values[name] = value;
                  }
                }
              }
            });
            return values;
          }
        },

        has: {

          field: function (identifier) {
            module.verbose('Checking for existence of a field with identifier',
                identifier);
            identifier = module.escape.string(identifier);
            if (typeof identifier !== 'string') {
              module.error(error.identifier, identifier);
            }
            if ($field.filter('#' + identifier).length > 0) {
              return true;
            }
            else if ($field.filter('[name="' + identifier + '"]').length > 0) {
              return true;
            }
            else if ($field.filter(
                    '[data-' + metadata.validate + '="' + identifier
                    + '"]').length > 0) {
              return true;
            }
            return false;
          }

        },

        escape: {
          string: function (text) {
            text = String(text);
            return text.replace(regExp.escape, '\\$&');
          }
        },

        add: {
          prompt: function (identifier, errors) {
            var
                $field = module.get.field(identifier),
                $fieldGroup = $field.closest($group),
                $prompt = $fieldGroup.children(selector.prompt),
                promptExists = ($prompt.length !== 0)
            ;
            errors = (typeof errors == 'string')
                ? [errors]
                : errors
            ;
            module.verbose('Adding field error state', identifier);
            $fieldGroup
            .addClass(className.error)
            ;
            if (settings.inline) {
              if (!promptExists) {
                $prompt = settings.templates.prompt(errors);
                $prompt
                .appendTo($fieldGroup)
                ;
              }
              $prompt
              .html(errors[0])
              ;
              if (!promptExists) {
                if (settings.transition && $.fn.transition !== undefined
                    && $module.transition('is supported')) {
                  module.verbose('Displaying error with css transition',
                      settings.transition);
                  $prompt.transition(settings.transition + ' in',
                      settings.duration);
                }
                else {
                  module.verbose(
                      'Displaying error with fallback javascript animation');
                  $prompt
                  .fadeIn(settings.duration)
                  ;
                }
              }
              else {
                module.verbose(
                    'Inline errors are disabled, no inline error added',
                    identifier);
              }
            }
          },
          errors: function (errors) {
            module.debug('Adding form error messages', errors);
            module.set.error();
            $message
            .html(settings.templates.error(errors))
            ;
          }
        },

        remove: {
          prompt: function (identifier) {
            var
                $field = module.get.field(identifier),
                $fieldGroup = $field.closest($group),
                $prompt = $fieldGroup.children(selector.prompt)
            ;
            $fieldGroup
            .removeClass(className.error)
            ;
            if (settings.inline && $prompt.is(':visible')) {
              module.verbose('Removing prompt for field', identifier);
              if (settings.transition && $.fn.transition !== undefined
                  && $module.transition('is supported')) {
                $prompt.transition(settings.transition + ' out',
                    settings.duration, function () {
                      $prompt.remove();
                    });
              }
              else {
                $prompt
                .fadeOut(settings.duration, function () {
                  $prompt.remove();
                })
                ;
              }
            }
          }
        },

        set: {
          success: function () {
            $module
            .removeClass(className.error)
            .addClass(className.success)
            ;
          },
          defaults: function () {
            $field
            .each(function () {
              var
                  $field = $(this),
                  isCheckbox = ($field.filter(selector.checkbox).length > 0),
                  value = (isCheckbox)
                      ? $field.is(':checked')
                      : $field.val()
              ;
              $field.data(metadata.defaultValue, value);
            })
            ;
          },
          error: function () {
            $module
            .removeClass(className.success)
            .addClass(className.error)
            ;
          },
          value: function (field, value) {
            var
                fields = {}
            ;
            fields[field] = value;
            return module.set.values.call(element, fields);
          },
          values: function (fields) {
            if ($.isEmptyObject(fields)) {
              return;
            }
            $.each(fields, function (key, value) {
              var
                  $field = module.get.field(key),
                  $element = $field.parent(),
                  isMultiple = $.isArray(value),
                  isCheckbox = $element.is(selector.uiCheckbox),
                  isDropdown = $element.is(selector.uiDropdown),
                  isRadio = ($field.is(selector.radio) && isCheckbox),
                  fieldExists = ($field.length > 0),
                  $multipleField
              ;
              if (fieldExists) {
                if (isMultiple && isCheckbox) {
                  module.verbose('Selecting multiple', value, $field);
                  $element.checkbox('uncheck');
                  $.each(value, function (index, value) {
                    $multipleField = $field.filter('[value="' + value + '"]');
                    $element = $multipleField.parent();
                    if ($multipleField.length > 0) {
                      $element.checkbox('check');
                    }
                  });
                }
                else if (isRadio) {
                  module.verbose('Selecting radio value', value, $field);
                  $field.filter('[value="' + value + '"]')
                  .parent(selector.uiCheckbox)
                  .checkbox('check')
                  ;
                }
                else if (isCheckbox) {
                  module.verbose('Setting checkbox value', value, $element);
                  if (value === true) {
                    $element.checkbox('check');
                  }
                  else {
                    $element.checkbox('uncheck');
                  }
                }
                else if (isDropdown) {
                  module.verbose('Setting dropdown value', value, $element);
                  $element.dropdown('set selected', value);
                }
                else {
                  module.verbose('Setting field value', value, $field);
                  $field.val(value);
                }
              }
            });
          }
        },

        validate: {

          form: function (event, ignoreCallbacks) {
            var
                values = module.get.values(),
                apiRequest
            ;

            // input keydown event will fire submit repeatedly by browser default
            if (keyHeldDown) {
              return false;
            }

            // reset errors
            formErrors = [];
            if (module.determine.isValid()) {
              module.debug('Form has no validation errors, submitting');
              module.set.success();
              if (ignoreCallbacks !== true) {
                return settings.onSuccess.call(element, event, values);
              }
            }
            else {
              module.debug('Form has errors');
              module.set.error();
              if (!settings.inline) {
                module.add.errors(formErrors);
              }
              // prevent ajax submit
              if ($module.data('moduleApi') !== undefined) {
                event.stopImmediatePropagation();
              }
              if (ignoreCallbacks !== true) {
                return settings.onFailure.call(element, formErrors, values);
              }
            }
          },

          // takes a validation object and returns whether field passes validation
          field: function (field, fieldName, showErrors) {
            showErrors = (showErrors !== undefined)
                ? showErrors
                : true
            ;
            if (typeof field == 'string') {
              module.verbose('Validating field', field);
              fieldName = field;
              field = validation[field];
            }
            var
                identifier = field.identifier || fieldName,
                $field = module.get.field(identifier),
                $dependsField = (field.depends)
                    ? module.get.field(field.depends)
                    : false,
                fieldValid = true,
                fieldErrors = []
            ;
            if (!field.identifier) {
              module.debug('Using field name as identifier', identifier);
              field.identifier = identifier;
            }
            if ($field.prop('disabled')) {
              module.debug('Field is disabled. Skipping', identifier);
              fieldValid = true;
            }
            else if (field.optional && module.is.blank($field)) {
              module.debug('Field is optional and blank. Skipping', identifier);
              fieldValid = true;
            }
            else if (field.depends && module.is.empty($dependsField)) {
              module.debug(
                  'Field depends on another value that is not present or empty. Skipping',
                  $dependsField);
              fieldValid = true;
            }
            else if (field.rules !== undefined) {
              $.each(field.rules, function (index, rule) {
                if (module.has.field(identifier) && !( module.validate.rule(
                        field, rule) )) {
                  module.debug('Field is invalid', identifier, rule.type);
                  fieldErrors.push(module.get.prompt(rule, field));
                  fieldValid = false;
                }
              });
            }
            if (fieldValid) {
              if (showErrors) {
                module.remove.prompt(identifier, fieldErrors);
                settings.onValid.call($field);
              }
            }
            else {
              if (showErrors) {
                formErrors = formErrors.concat(fieldErrors);
                module.add.prompt(identifier, fieldErrors);
                settings.onInvalid.call($field, fieldErrors);
              }
              return false;
            }
            return true;
          },

          // takes validation rule and returns whether field passes rule
          rule: function (field, rule) {
            var
                $field = module.get.field(field.identifier),
                type = rule.type,
                value = $field.val(),
                isValid = true,
                ancillary = module.get.ancillaryValue(rule),
                ruleName = module.get.ruleName(rule),
                ruleFunction = settings.rules[ruleName]
            ;
            if (!$.isFunction(ruleFunction)) {
              module.error(error.noRule, ruleName);
              return;
            }
            // cast to string avoiding encoding special values
            value = (value === undefined || value === '' || value === null)
                ? ''
                : $.trim(value + '')
            ;
            return ruleFunction.call($field, value, ancillary);
          }
        },

        setting: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            settings[name] = value;
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };
      module.initialize();
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.form.settings = {

    name: 'Form',
    namespace: 'form',

    debug: false,
    verbose: false,
    performance: true,

    fields: false,

    keyboardShortcuts: true,
    on: 'submit',
    inline: false,

    delay: 200,
    revalidate: true,

    transition: 'scale',
    duration: 200,

    onValid: function () {
    },
    onInvalid: function () {
    },
    onSuccess: function () {
      return true;
    },
    onFailure: function () {
      return false;
    },

    metadata: {
      defaultValue: 'default',
      validate: 'validate'
    },

    regExp: {
      htmlID: /^[a-zA-Z][\w:.-]*$/g,
      bracket: /\[(.*)\]/i,
      decimal: /^\d+\.?\d*$/,
      email: /^[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i,
      escape: /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,
      flags: /^\/(.*)\/(.*)?/,
      integer: /^\-?\d+$/,
      number: /^\-?\d*(\.\d+)?$/,
      url: /(https?:\/\/(?:www\.|(?!www))[^\s\.]+\.[^\s]{2,}|www\.[^\s]+\.[^\s]{2,})/i
    },

    text: {
      unspecifiedRule: 'Please enter a valid value',
      unspecifiedField: 'This field'
    },

    prompt: {
      empty: '{name} must have a value',
      checked: '{name} must be checked',
      email: '{name} must be a valid e-mail',
      url: '{name} must be a valid url',
      regExp: '{name} is not formatted correctly',
      integer: '{name} must be an integer',
      decimal: '{name} must be a decimal number',
      number: '{name} must be set to a number',
      is: '{name} must be "{ruleValue}"',
      isExactly: '{name} must be exactly "{ruleValue}"',
      not: '{name} cannot be set to "{ruleValue}"',
      notExactly: '{name} cannot be set to exactly "{ruleValue}"',
      contain: '{name} cannot contain "{ruleValue}"',
      containExactly: '{name} cannot contain exactly "{ruleValue}"',
      doesntContain: '{name} must contain  "{ruleValue}"',
      doesntContainExactly: '{name} must contain exactly "{ruleValue}"',
      minLength: '{name} must be at least {ruleValue} characters',
      length: '{name} must be at least {ruleValue} characters',
      exactLength: '{name} must be exactly {ruleValue} characters',
      maxLength: '{name} cannot be longer than {ruleValue} characters',
      match: '{name} must match {ruleValue} field',
      different: '{name} must have a different value than {ruleValue} field',
      creditCard: '{name} must be a valid credit card number',
      minCount: '{name} must have at least {ruleValue} choices',
      exactCount: '{name} must have exactly {ruleValue} choices',
      maxCount: '{name} must have {ruleValue} or less choices'
    },

    selector: {
      checkbox: 'input[type="checkbox"], input[type="radio"]',
      clear: '.clear',
      field: 'input, textarea, select',
      group: '.field',
      input: 'input',
      message: '.error.message',
      prompt: '.prompt.label',
      radio: 'input[type="radio"]',
      reset: '.reset:not([type="reset"])',
      submit: '.submit:not([type="submit"])',
      uiCheckbox: '.ui.checkbox',
      uiDropdown: '.ui.dropdown'
    },

    className: {
      error: 'error',
      label: 'ui prompt label',
      pressed: 'down',
      success: 'success'
    },

    error: {
      identifier: 'You must specify a string identifier for each field',
      method: 'The method you called is not defined.',
      noRule: 'There is no rule matching the one you specified',
      oldSyntax: 'Starting in 2.0 forms now only take a single settings object. Validation settings converted to new syntax automatically.'
    },

    templates: {

      // template that produces error message
      error: function (errors) {
        var
            html = '<ul class="list">'
        ;
        $.each(errors, function (index, value) {
          html += '<li>' + value + '</li>';
        });
        html += '</ul>';
        return $(html);
      },

      // template that produces label
      prompt: function (errors) {
        return $('<div/>')
        .addClass('ui basic red pointing prompt label')
        .html(errors[0])
            ;
      }
    },

    rules: {

      // is not empty or blank string
      empty: function (value) {
        return !(value === undefined || '' === value || $.isArray(value)
        && value.length === 0);
      },

      // checkbox checked
      checked: function () {
        return ($(this).filter(':checked').length > 0);
      },

      // is most likely an email
      email: function (value) {
        return $.fn.form.settings.regExp.email.test(value);
      },

      // value is most likely url
      url: function (value) {
        return $.fn.form.settings.regExp.url.test(value);
      },

      // matches specified regExp
      regExp: function (value, regExp) {
        if (regExp instanceof RegExp) {
          return value.match(regExp);
        }
        var
            regExpParts = regExp.match($.fn.form.settings.regExp.flags),
            flags
        ;
        // regular expression specified as /baz/gi (flags)
        if (regExpParts) {
          regExp = (regExpParts.length >= 2)
              ? regExpParts[1]
              : regExp
          ;
          flags = (regExpParts.length >= 3)
              ? regExpParts[2]
              : ''
          ;
        }
        return value.match(new RegExp(regExp, flags));
      },

      // is valid integer or matches range
      integer: function (value, range) {
        var
            intRegExp = $.fn.form.settings.regExp.integer,
            min,
            max,
            parts
        ;
        if (!range || ['', '..'].indexOf(range) !== -1) {
          // do nothing
        }
        else if (range.indexOf('..') == -1) {
          if (intRegExp.test(range)) {
            min = max = range - 0;
          }
        }
        else {
          parts = range.split('..', 2);
          if (intRegExp.test(parts[0])) {
            min = parts[0] - 0;
          }
          if (intRegExp.test(parts[1])) {
            max = parts[1] - 0;
          }
        }
        return (
            intRegExp.test(value) &&
            (min === undefined || value >= min) &&
            (max === undefined || value <= max)
        );
      },

      // is valid number (with decimal)
      decimal: function (value) {
        return $.fn.form.settings.regExp.decimal.test(value);
      },

      // is valid number
      number: function (value) {
        return $.fn.form.settings.regExp.number.test(value);
      },

      // is value (case insensitive)
      is: function (value, text) {
        text = (typeof text == 'string')
            ? text.toLowerCase()
            : text
        ;
        value = (typeof value == 'string')
            ? value.toLowerCase()
            : value
        ;
        return (value == text);
      },

      // is value
      isExactly: function (value, text) {
        return (value == text);
      },

      // value is not another value (case insensitive)
      not: function (value, notValue) {
        value = (typeof value == 'string')
            ? value.toLowerCase()
            : value
        ;
        notValue = (typeof notValue == 'string')
            ? notValue.toLowerCase()
            : notValue
        ;
        return (value != notValue);
      },

      // value is not another value (case sensitive)
      notExactly: function (value, notValue) {
        return (value != notValue);
      },

      // value contains text (insensitive)
      contains: function (value, text) {
        // escape regex characters
        text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
        return (value.search(new RegExp(text, 'i')) !== -1);
      },

      // value contains text (case sensitive)
      containsExactly: function (value, text) {
        // escape regex characters
        text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
        return (value.search(new RegExp(text)) !== -1);
      },

      // value contains text (insensitive)
      doesntContain: function (value, text) {
        // escape regex characters
        text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
        return (value.search(new RegExp(text, 'i')) === -1);
      },

      // value contains text (case sensitive)
      doesntContainExactly: function (value, text) {
        // escape regex characters
        text = text.replace($.fn.form.settings.regExp.escape, "\\$&");
        return (value.search(new RegExp(text)) === -1);
      },

      // is at least string length
      minLength: function (value, requiredLength) {
        return (value !== undefined)
            ? (value.length >= requiredLength)
            : false
            ;
      },

      // see rls notes for 2.0.6 (this is a duplicate of minLength)
      length: function (value, requiredLength) {
        return (value !== undefined)
            ? (value.length >= requiredLength)
            : false
            ;
      },

      // is exactly length
      exactLength: function (value, requiredLength) {
        return (value !== undefined)
            ? (value.length == requiredLength)
            : false
            ;
      },

      // is less than length
      maxLength: function (value, maxLength) {
        return (value !== undefined)
            ? (value.length <= maxLength)
            : false
            ;
      },

      // matches another field
      match: function (value, identifier) {
        var
            $form = $(this),
            matchingValue
        ;
        if ($('[data-validate="' + identifier + '"]').length > 0) {
          matchingValue = $('[data-validate="' + identifier + '"]').val();
        }
        else if ($('#' + identifier).length > 0) {
          matchingValue = $('#' + identifier).val();
        }
        else if ($('[name="' + identifier + '"]').length > 0) {
          matchingValue = $('[name="' + identifier + '"]').val();
        }
        else if ($('[name="' + identifier + '[]"]').length > 0) {
          matchingValue = $('[name="' + identifier + '[]"]');
        }
        return (matchingValue !== undefined)
            ? ( value.toString() == matchingValue.toString() )
            : false
            ;
      },

      // different than another field
      different: function (value, identifier) {
        // use either id or name of field
        var
            $form = $(this),
            matchingValue
        ;
        if ($('[data-validate="' + identifier + '"]').length > 0) {
          matchingValue = $('[data-validate="' + identifier + '"]').val();
        }
        else if ($('#' + identifier).length > 0) {
          matchingValue = $('#' + identifier).val();
        }
        else if ($('[name="' + identifier + '"]').length > 0) {
          matchingValue = $('[name="' + identifier + '"]').val();
        }
        else if ($('[name="' + identifier + '[]"]').length > 0) {
          matchingValue = $('[name="' + identifier + '[]"]');
        }
        return (matchingValue !== undefined)
            ? ( value.toString() !== matchingValue.toString() )
            : false
            ;
      },

      creditCard: function (cardNumber, cardTypes) {
        var
            cards = {
              visa: {
                pattern: /^4/,
                length: [16]
              },
              amex: {
                pattern: /^3[47]/,
                length: [15]
              },
              mastercard: {
                pattern: /^5[1-5]/,
                length: [16]
              },
              discover: {
                pattern: /^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)/,
                length: [16]
              },
              unionPay: {
                pattern: /^(62|88)/,
                length: [16, 17, 18, 19]
              },
              jcb: {
                pattern: /^35(2[89]|[3-8][0-9])/,
                length: [16]
              },
              maestro: {
                pattern: /^(5018|5020|5038|6304|6759|676[1-3])/,
                length: [12, 13, 14, 15, 16, 17, 18, 19]
              },
              dinersClub: {
                pattern: /^(30[0-5]|^36)/,
                length: [14]
              },
              laser: {
                pattern: /^(6304|670[69]|6771)/,
                length: [16, 17, 18, 19]
              },
              visaElectron: {
                pattern: /^(4026|417500|4508|4844|491(3|7))/,
                length: [16]
              }
            },
            valid = {},
            validCard = false,
            requiredTypes = (typeof cardTypes == 'string')
                ? cardTypes.split(',')
                : false,
            unionPay,
            validation
        ;

        if (typeof cardNumber !== 'string' || cardNumber.length === 0) {
          return;
        }

        // allow dashes in card
        cardNumber = cardNumber.replace(/[\-]/g, '');

        // verify card types
        if (requiredTypes) {
          $.each(requiredTypes, function (index, type) {
            // verify each card type
            validation = cards[type];
            if (validation) {
              valid = {
                length: ($.inArray(cardNumber.length, validation.length)
                !== -1),
                pattern: (cardNumber.search(validation.pattern) !== -1)
              };
              if (valid.length && valid.pattern) {
                validCard = true;
              }
            }
          });

          if (!validCard) {
            return false;
          }
        }

        // skip luhn for UnionPay
        unionPay = {
          number: ($.inArray(cardNumber.length, cards.unionPay.length) !== -1),
          pattern: (cardNumber.search(cards.unionPay.pattern) !== -1)
        };
        if (unionPay.number && unionPay.pattern) {
          return true;
        }

        // verify luhn, adapted from  <https://gist.github.com/2134376>
        var
            length = cardNumber.length,
            multiple = 0,
            producedValue = [
              [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
              [0, 2, 4, 6, 8, 1, 3, 5, 7, 9]
            ],
            sum = 0
        ;
        while (length--) {
          sum += producedValue[multiple][parseInt(cardNumber.charAt(length),
              10)];
          multiple ^= 1;
        }
        return (sum % 10 === 0 && sum > 0);
      },

      minCount: function (value, minCount) {
        if (minCount == 0) {
          return true;
        }
        if (minCount == 1) {
          return (value !== '');
        }
        return (value.split(',').length >= minCount);
      },

      exactCount: function (value, exactCount) {
        if (exactCount == 0) {
          return (value === '');
        }
        if (exactCount == 1) {
          return (value !== '' && value.search(',') === -1);
        }
        return (value.split(',').length == exactCount);
      },

      maxCount: function (value, maxCount) {
        if (maxCount == 0) {
          return false;
        }
        if (maxCount == 1) {
          return (value.search(',') === -1);
        }
        return (value.split(',').length <= maxCount);
      }
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Accordion
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.accordion = function (parameters) {
    var
        $allModules = $(this),

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) {
              setTimeout(callback, 0);
            },

        returnedValue
    ;
    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.accordion.settings, parameters)
              : $.extend({}, $.fn.accordion.settings),

          className = settings.className,
          namespace = settings.namespace,
          selector = settings.selector,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,
          moduleSelector = $allModules.selector || '',

          $module = $(this),
          $title = $module.find(selector.title),
          $content = $module.find(selector.content),

          element = this,
          instance = $module.data(moduleNamespace),
          observer,
          module
      ;

      module = {

        initialize: function () {
          module.debug('Initializing', $module);
          module.bind.events();
          if (settings.observeChanges) {
            module.observeChanges();
          }
          module.instantiate();
        },

        instantiate: function () {
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.debug('Destroying previous instance', $module);
          $module
          .off(eventNamespace)
          .removeData(moduleNamespace)
          ;
        },

        refresh: function () {
          $title = $module.find(selector.title);
          $content = $module.find(selector.content);
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            observer = new MutationObserver(function (mutations) {
              module.debug('DOM tree modified, updating selector cache');
              module.refresh();
            });
            observer.observe(element, {
              childList: true,
              subtree: true
            });
            module.debug('Setting up mutation observer', observer);
          }
        },

        bind: {
          events: function () {
            module.debug('Binding delegated events');
            $module
            .on(settings.on + eventNamespace, selector.trigger,
                module.event.click)
            ;
          }
        },

        event: {
          click: function () {
            module.toggle.call(this);
          }
        },

        toggle: function (query) {
          var
              $activeTitle = (query !== undefined)
                  ? (typeof query === 'number')
                      ? $title.eq(query)
                      : $(query).closest(selector.title)
                  : $(this).closest(selector.title),
              $activeContent = $activeTitle.next($content),
              isAnimating = $activeContent.hasClass(className.animating),
              isActive = $activeContent.hasClass(className.active),
              isOpen = (isActive && !isAnimating),
              isOpening = (!isActive && isAnimating)
          ;
          module.debug('Toggling visibility of content', $activeTitle);
          if (isOpen || isOpening) {
            if (settings.collapsible) {
              module.close.call($activeTitle);
            }
            else {
              module.debug(
                  'Cannot close accordion content collapsing is disabled');
            }
          }
          else {
            module.open.call($activeTitle);
          }
        },

        open: function (query) {
          var
              $activeTitle = (query !== undefined)
                  ? (typeof query === 'number')
                      ? $title.eq(query)
                      : $(query).closest(selector.title)
                  : $(this).closest(selector.title),
              $activeContent = $activeTitle.next($content),
              isAnimating = $activeContent.hasClass(className.animating),
              isActive = $activeContent.hasClass(className.active),
              isOpen = (isActive || isAnimating)
          ;
          if (isOpen) {
            module.debug('Accordion already open, skipping', $activeContent);
            return;
          }
          module.debug('Opening accordion content', $activeTitle);
          settings.onOpening.call($activeContent);
          if (settings.exclusive) {
            module.closeOthers.call($activeTitle);
          }
          $activeTitle
          .addClass(className.active)
          ;
          $activeContent
          .stop(true, true)
          .addClass(className.animating)
          ;
          if (settings.animateChildren) {
            if ($.fn.transition !== undefined && $module.transition(
                    'is supported')) {
              $activeContent
              .children()
              .transition({
                animation: 'fade in',
                queue: false,
                useFailSafe: true,
                debug: settings.debug,
                verbose: settings.verbose,
                duration: settings.duration
              })
              ;
            }
            else {
              $activeContent
              .children()
              .stop(true, true)
              .animate({
                opacity: 1
              }, settings.duration, module.resetOpacity)
              ;
            }
          }
          $activeContent
          .slideDown(settings.duration, settings.easing, function () {
            $activeContent
            .removeClass(className.animating)
            .addClass(className.active)
            ;
            module.reset.display.call(this);
            settings.onOpen.call(this);
            settings.onChange.call(this);
          })
          ;
        },

        close: function (query) {
          var
              $activeTitle = (query !== undefined)
                  ? (typeof query === 'number')
                      ? $title.eq(query)
                      : $(query).closest(selector.title)
                  : $(this).closest(selector.title),
              $activeContent = $activeTitle.next($content),
              isAnimating = $activeContent.hasClass(className.animating),
              isActive = $activeContent.hasClass(className.active),
              isOpening = (!isActive && isAnimating),
              isClosing = (isActive && isAnimating)
          ;
          if ((isActive || isOpening) && !isClosing) {
            module.debug('Closing accordion content', $activeContent);
            settings.onClosing.call($activeContent);
            $activeTitle
            .removeClass(className.active)
            ;
            $activeContent
            .stop(true, true)
            .addClass(className.animating)
            ;
            if (settings.animateChildren) {
              if ($.fn.transition !== undefined && $module.transition(
                      'is supported')) {
                $activeContent
                .children()
                .transition({
                  animation: 'fade out',
                  queue: false,
                  useFailSafe: true,
                  debug: settings.debug,
                  verbose: settings.verbose,
                  duration: settings.duration
                })
                ;
              }
              else {
                $activeContent
                .children()
                .stop(true, true)
                .animate({
                  opacity: 0
                }, settings.duration, module.resetOpacity)
                ;
              }
            }
            $activeContent
            .slideUp(settings.duration, settings.easing, function () {
              $activeContent
              .removeClass(className.animating)
              .removeClass(className.active)
              ;
              module.reset.display.call(this);
              settings.onClose.call(this);
              settings.onChange.call(this);
            })
            ;
          }
        },

        closeOthers: function (index) {
          var
              $activeTitle = (index !== undefined)
                  ? $title.eq(index)
                  : $(this).closest(selector.title),
              $parentTitles = $activeTitle.parents(selector.content).prev(
                  selector.title),
              $activeAccordion = $activeTitle.closest(selector.accordion),
              activeSelector = selector.title + '.' + className.active
                  + ':visible',
              activeContent = selector.content + '.' + className.active
                  + ':visible',
              $openTitles,
              $nestedTitles,
              $openContents
          ;
          if (settings.closeNested) {
            $openTitles = $activeAccordion.find(activeSelector).not(
                $parentTitles);
            $openContents = $openTitles.next($content);
          }
          else {
            $openTitles = $activeAccordion.find(activeSelector).not(
                $parentTitles);
            $nestedTitles = $activeAccordion.find(activeContent).find(
                activeSelector).not($parentTitles);
            $openTitles = $openTitles.not($nestedTitles);
            $openContents = $openTitles.next($content);
          }
          if (($openTitles.length > 0)) {
            module.debug('Exclusive enabled, closing other content',
                $openTitles);
            $openTitles
            .removeClass(className.active)
            ;
            $openContents
            .removeClass(className.animating)
            .stop(true, true)
            ;
            if (settings.animateChildren) {
              if ($.fn.transition !== undefined && $module.transition(
                      'is supported')) {
                $openContents
                .children()
                .transition({
                  animation: 'fade out',
                  useFailSafe: true,
                  debug: settings.debug,
                  verbose: settings.verbose,
                  duration: settings.duration
                })
                ;
              }
              else {
                $openContents
                .children()
                .stop(true, true)
                .animate({
                  opacity: 0
                }, settings.duration, module.resetOpacity)
                ;
              }
            }
            $openContents
            .slideUp(settings.duration, settings.easing, function () {
              $(this).removeClass(className.active);
              module.reset.display.call(this);
            })
            ;
          }
        },

        reset: {

          display: function () {
            module.verbose('Removing inline display from element', this);
            $(this).css('display', '');
            if ($(this).attr('style') === '') {
              $(this)
              .attr('style', '')
              .removeAttr('style')
              ;
            }
          },

          opacity: function () {
            module.verbose('Removing inline opacity from element', this);
            $(this).css('opacity', '');
            if ($(this).attr('style') === '') {
              $(this)
              .attr('style', '')
              .removeAttr('style')
              ;
            }
          },

        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          module.debug('Changing internal', name, value);
          if (value !== undefined) {
            if ($.isPlainObject(name)) {
              $.extend(true, module, name);
            }
            else {
              module[name] = value;
            }
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };
      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;
    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.accordion.settings = {

    name: 'Accordion',
    namespace: 'accordion',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    on: 'click', // event on title that opens accordion

    observeChanges: true,  // whether accordion should automatically refresh on DOM insertion

    exclusive: true,  // whether a single accordion content panel should be open at once
    collapsible: true,  // whether accordion content can be closed
    closeNested: false, // whether nested content should be closed when a panel is closed
    animateChildren: true,  // whether children opacity should be animated

    duration: 350, // duration of animation
    easing: 'easeOutQuad', // easing equation for animation

    onOpening: function () {
    }, // callback before open animation
    onOpen: function () {
    }, // callback after open animation
    onClosing: function () {
    }, // callback before closing animation
    onClose: function () {
    }, // callback after closing animation
    onChange: function () {
    }, // callback after closing or opening animation

    error: {
      method: 'The method you called is not defined'
    },

    className: {
      active: 'active',
      animating: 'animating'
    },

    selector: {
      accordion: '.accordion',
      title: '.title',
      trigger: '.title',
      content: '.content'
    }

  };

// Adds easing
  $.extend($.easing, {
    easeOutQuad: function (x, t, b, c, d) {
      return -c * (t /= d) * (t - 2) + b;
    }
  });

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Checkbox
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.checkbox = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = $.extend(true, {}, $.fn.checkbox.settings, parameters),

          className = settings.className,
          namespace = settings.namespace,
          selector = settings.selector,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $label = $(this).children(selector.label),
          $input = $(this).children(selector.input),
          input = $input[0],

          initialLoad = false,
          shortcutPressed = false,
          instance = $module.data(moduleNamespace),

          observer,
          element = this,
          module
      ;

      module = {

        initialize: function () {
          module.verbose('Initializing checkbox', settings);

          module.create.label();
          module.bind.events();

          module.set.tabbable();
          module.hide.input();

          module.observeChanges();
          module.instantiate();
          module.setup();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying module');
          module.unbind.events();
          module.show.input();
          $module.removeData(moduleNamespace);
        },

        fix: {
          reference: function () {
            if ($module.is(selector.input)) {
              module.debug(
                  'Behavior called on <input> adjusting invoked element');
              $module = $module.closest(selector.checkbox);
              module.refresh();
            }
          }
        },

        setup: function () {
          module.set.initialLoad();
          if (module.is.indeterminate()) {
            module.debug('Initial value is indeterminate');
            module.indeterminate();
          }
          else if (module.is.checked()) {
            module.debug('Initial value is checked');
            module.check();
          }
          else {
            module.debug('Initial value is unchecked');
            module.uncheck();
          }
          module.remove.initialLoad();
        },

        refresh: function () {
          $label = $module.children(selector.label);
          $input = $module.children(selector.input);
          input = $input[0];
        },

        hide: {
          input: function () {
            module.verbose('Modifying <input> z-index to be unselectable');
            $input.addClass(className.hidden);
          }
        },
        show: {
          input: function () {
            module.verbose('Modifying <input> z-index to be selectable');
            $input.removeClass(className.hidden);
          }
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            observer = new MutationObserver(function (mutations) {
              module.debug('DOM tree modified, updating selector cache');
              module.refresh();
            });
            observer.observe(element, {
              childList: true,
              subtree: true
            });
            module.debug('Setting up mutation observer', observer);
          }
        },

        attachEvents: function (selector, event) {
          var
              $element = $(selector)
          ;
          event = $.isFunction(module[event])
              ? module[event]
              : module.toggle
          ;
          if ($element.length > 0) {
            module.debug('Attaching checkbox events to element', selector,
                event);
            $element
            .on('click' + eventNamespace, event)
            ;
          }
          else {
            module.error(error.notFound);
          }
        },

        event: {
          click: function (event) {
            var
                $target = $(event.target)
            ;
            if ($target.is(selector.input)) {
              module.verbose(
                  'Using default check action on initialized checkbox');
              return;
            }
            if ($target.is(selector.link)) {
              module.debug('Clicking link inside checkbox, skipping toggle');
              return;
            }
            module.toggle();
            $input.focus();
            event.preventDefault();
          },
          keydown: function (event) {
            var
                key = event.which,
                keyCode = {
                  enter: 13,
                  space: 32,
                  escape: 27
                }
            ;
            if (key == keyCode.escape) {
              module.verbose('Escape key pressed blurring field');
              $input.blur();
              shortcutPressed = true;
            }
            else if (!event.ctrlKey && ( key == keyCode.space || key
                == keyCode.enter)) {
              module.verbose('Enter/space key pressed, toggling checkbox');
              module.toggle();
              shortcutPressed = true;
            }
            else {
              shortcutPressed = false;
            }
          },
          keyup: function (event) {
            if (shortcutPressed) {
              event.preventDefault();
            }
          }
        },

        check: function () {
          if (!module.should.allowCheck()) {
            return;
          }
          module.debug('Checking checkbox', $input);
          module.set.checked();
          if (!module.should.ignoreCallbacks()) {
            settings.onChecked.call(input);
            settings.onChange.call(input);
          }
        },

        uncheck: function () {
          if (!module.should.allowUncheck()) {
            return;
          }
          module.debug('Unchecking checkbox');
          module.set.unchecked();
          if (!module.should.ignoreCallbacks()) {
            settings.onUnchecked.call(input);
            settings.onChange.call(input);
          }
        },

        indeterminate: function () {
          if (module.should.allowIndeterminate()) {
            module.debug('Checkbox is already indeterminate');
            return;
          }
          module.debug('Making checkbox indeterminate');
          module.set.indeterminate();
          if (!module.should.ignoreCallbacks()) {
            settings.onIndeterminate.call(input);
            settings.onChange.call(input);
          }
        },

        determinate: function () {
          if (module.should.allowDeterminate()) {
            module.debug('Checkbox is already determinate');
            return;
          }
          module.debug('Making checkbox determinate');
          module.set.determinate();
          if (!module.should.ignoreCallbacks()) {
            settings.onDeterminate.call(input);
            settings.onChange.call(input);
          }
        },

        enable: function () {
          if (module.is.enabled()) {
            module.debug('Checkbox is already enabled');
            return;
          }
          module.debug('Enabling checkbox');
          module.set.enabled();
          settings.onEnable.call(input);
          // preserve legacy callbacks
          settings.onEnabled.call(input);
        },

        disable: function () {
          if (module.is.disabled()) {
            module.debug('Checkbox is already disabled');
            return;
          }
          module.debug('Disabling checkbox');
          module.set.disabled();
          settings.onDisable.call(input);
          // preserve legacy callbacks
          settings.onDisabled.call(input);
        },

        get: {
          radios: function () {
            var
                name = module.get.name()
            ;
            return $('input[name="' + name + '"]').closest(selector.checkbox);
          },
          otherRadios: function () {
            return module.get.radios().not($module);
          },
          name: function () {
            return $input.attr('name');
          }
        },

        is: {
          initialLoad: function () {
            return initialLoad;
          },
          radio: function () {
            return ($input.hasClass(className.radio) || $input.attr('type')
            == 'radio');
          },
          indeterminate: function () {
            return $input.prop('indeterminate') !== undefined && $input.prop(
                    'indeterminate');
          },
          checked: function () {
            return $input.prop('checked') !== undefined && $input.prop(
                    'checked');
          },
          disabled: function () {
            return $input.prop('disabled') !== undefined && $input.prop(
                    'disabled');
          },
          enabled: function () {
            return !module.is.disabled();
          },
          determinate: function () {
            return !module.is.indeterminate();
          },
          unchecked: function () {
            return !module.is.checked();
          }
        },

        should: {
          allowCheck: function () {
            if (module.is.determinate() && module.is.checked()
                && !module.should.forceCallbacks()) {
              module.debug(
                  'Should not allow check, checkbox is already checked');
              return false;
            }
            if (settings.beforeChecked.apply(input) === false) {
              module.debug('Should not allow check, beforeChecked cancelled');
              return false;
            }
            return true;
          },
          allowUncheck: function () {
            if (module.is.determinate() && module.is.unchecked()
                && !module.should.forceCallbacks()) {
              module.debug(
                  'Should not allow uncheck, checkbox is already unchecked');
              return false;
            }
            if (settings.beforeUnchecked.apply(input) === false) {
              module.debug(
                  'Should not allow uncheck, beforeUnchecked cancelled');
              return false;
            }
            return true;
          },
          allowIndeterminate: function () {
            if (module.is.indeterminate() && !module.should.forceCallbacks()) {
              module.debug(
                  'Should not allow indeterminate, checkbox is already indeterminate');
              return false;
            }
            if (settings.beforeIndeterminate.apply(input) === false) {
              module.debug(
                  'Should not allow indeterminate, beforeIndeterminate cancelled');
              return false;
            }
            return true;
          },
          allowDeterminate: function () {
            if (module.is.determinate() && !module.should.forceCallbacks()) {
              module.debug(
                  'Should not allow determinate, checkbox is already determinate');
              return false;
            }
            if (settings.beforeDeterminate.apply(input) === false) {
              module.debug(
                  'Should not allow determinate, beforeDeterminate cancelled');
              return false;
            }
            return true;
          },
          forceCallbacks: function () {
            return (module.is.initialLoad() && settings.fireOnInit);
          },
          ignoreCallbacks: function () {
            return (initialLoad && !settings.fireOnInit);
          }
        },

        can: {
          change: function () {
            return !( $module.hasClass(className.disabled) || $module.hasClass(
                className.readOnly) || $input.prop('disabled') || $input.prop(
                'readonly') );
          },
          uncheck: function () {
            return (typeof settings.uncheckable === 'boolean')
                ? settings.uncheckable
                : !module.is.radio()
                ;
          }
        },

        set: {
          initialLoad: function () {
            initialLoad = true;
          },
          checked: function () {
            module.verbose('Setting class to checked');
            $module
            .removeClass(className.indeterminate)
            .addClass(className.checked)
            ;
            if (module.is.radio()) {
              module.uncheckOthers();
            }
            if (!module.is.indeterminate() && module.is.checked()) {
              module.debug(
                  'Input is already checked, skipping input property change');
              return;
            }
            module.verbose('Setting state to checked', input);
            $input
            .prop('indeterminate', false)
            .prop('checked', true)
            ;
            module.trigger.change();
          },
          unchecked: function () {
            module.verbose('Removing checked class');
            $module
            .removeClass(className.indeterminate)
            .removeClass(className.checked)
            ;
            if (!module.is.indeterminate() && module.is.unchecked()) {
              module.debug('Input is already unchecked');
              return;
            }
            module.debug('Setting state to unchecked');
            $input
            .prop('indeterminate', false)
            .prop('checked', false)
            ;
            module.trigger.change();
          },
          indeterminate: function () {
            module.verbose('Setting class to indeterminate');
            $module
            .addClass(className.indeterminate)
            ;
            if (module.is.indeterminate()) {
              module.debug(
                  'Input is already indeterminate, skipping input property change');
              return;
            }
            module.debug('Setting state to indeterminate');
            $input
            .prop('indeterminate', true)
            ;
            module.trigger.change();
          },
          determinate: function () {
            module.verbose('Removing indeterminate class');
            $module
            .removeClass(className.indeterminate)
            ;
            if (module.is.determinate()) {
              module.debug(
                  'Input is already determinate, skipping input property change');
              return;
            }
            module.debug('Setting state to determinate');
            $input
            .prop('indeterminate', false)
            ;
          },
          disabled: function () {
            module.verbose('Setting class to disabled');
            $module
            .addClass(className.disabled)
            ;
            if (module.is.disabled()) {
              module.debug(
                  'Input is already disabled, skipping input property change');
              return;
            }
            module.debug('Setting state to disabled');
            $input
            .prop('disabled', 'disabled')
            ;
            module.trigger.change();
          },
          enabled: function () {
            module.verbose('Removing disabled class');
            $module.removeClass(className.disabled);
            if (module.is.enabled()) {
              module.debug(
                  'Input is already enabled, skipping input property change');
              return;
            }
            module.debug('Setting state to enabled');
            $input
            .prop('disabled', false)
            ;
            module.trigger.change();
          },
          tabbable: function () {
            module.verbose('Adding tabindex to checkbox');
            if ($input.attr('tabindex') === undefined) {
              $input.attr('tabindex', 0);
            }
          }
        },

        remove: {
          initialLoad: function () {
            initialLoad = false;
          }
        },

        trigger: {
          change: function () {
            var
                events = document.createEvent('HTMLEvents'),
                inputElement = $input[0]
            ;
            if (inputElement) {
              module.verbose('Triggering native change event');
              events.initEvent('change', true, false);
              inputElement.dispatchEvent(events);
            }
          }
        },

        create: {
          label: function () {
            if ($input.prevAll(selector.label).length > 0) {
              $input.prev(selector.label).detach().insertAfter($input);
              module.debug('Moving existing label', $label);
            }
            else if (!module.has.label()) {
              $label = $('<label>').insertAfter($input);
              module.debug('Creating label', $label);
            }
          }
        },

        has: {
          label: function () {
            return ($label.length > 0);
          }
        },

        bind: {
          events: function () {
            module.verbose('Attaching checkbox events');
            $module
            .on('click' + eventNamespace, module.event.click)
            .on('keydown' + eventNamespace, selector.input,
                module.event.keydown)
            .on('keyup' + eventNamespace, selector.input, module.event.keyup)
            ;
          }
        },

        unbind: {
          events: function () {
            module.debug('Removing events');
            $module
            .off(eventNamespace)
            ;
          }
        },

        uncheckOthers: function () {
          var
              $radios = module.get.otherRadios()
          ;
          module.debug('Unchecking other radios', $radios);
          $radios.removeClass(className.checked);
        },

        toggle: function () {
          if (!module.can.change()) {
            if (!module.is.radio()) {
              module.debug(
                  'Checkbox is read-only or disabled, ignoring toggle');
            }
            return;
          }
          if (module.is.indeterminate() || module.is.unchecked()) {
            module.debug('Currently unchecked');
            module.check();
          }
          else if (module.is.checked() && module.can.uncheck()) {
            module.debug('Currently checked');
            module.uncheck();
          }
        },
        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.checkbox.settings = {

    name: 'Checkbox',
    namespace: 'checkbox',

    silent: false,
    debug: false,
    verbose: true,
    performance: true,

    // delegated event context
    uncheckable: 'auto',
    fireOnInit: false,

    onChange: function () {
    },

    beforeChecked: function () {
    },
    beforeUnchecked: function () {
    },
    beforeDeterminate: function () {
    },
    beforeIndeterminate: function () {
    },

    onChecked: function () {
    },
    onUnchecked: function () {
    },

    onDeterminate: function () {
    },
    onIndeterminate: function () {
    },

    onEnable: function () {
    },
    onDisable: function () {
    },

    // preserve misspelled callbacks (will be removed in 3.0)
    onEnabled: function () {
    },
    onDisabled: function () {
    },

    className: {
      checked: 'checked',
      indeterminate: 'indeterminate',
      disabled: 'disabled',
      hidden: 'hidden',
      radio: 'radio',
      readOnly: 'read-only'
    },

    error: {
      method: 'The method you called is not defined'
    },

    selector: {
      checkbox: '.ui.checkbox',
      label: 'label, .box',
      input: 'input[type="checkbox"], input[type="radio"]',
      link: 'a[href]'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Dimmer
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.dimmer = function (parameters) {
    var
        $allModules = $(this),

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.dimmer.settings, parameters)
              : $.extend({}, $.fn.dimmer.settings),

          selector = settings.selector,
          namespace = settings.namespace,
          className = settings.className,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,
          moduleSelector = $allModules.selector || '',

          clickEvent = ('ontouchstart' in document.documentElement)
              ? 'touchstart'
              : 'click',

          $module = $(this),
          $dimmer,
          $dimmable,

          element = this,
          instance = $module.data(moduleNamespace),
          module
      ;

      module = {

        preinitialize: function () {
          if (module.is.dimmer()) {

            $dimmable = $module.parent();
            $dimmer = $module;
          }
          else {
            $dimmable = $module;
            if (module.has.dimmer()) {
              if (settings.dimmerName) {
                $dimmer = $dimmable.find(selector.dimmer).filter(
                    '.' + settings.dimmerName);
              }
              else {
                $dimmer = $dimmable.find(selector.dimmer);
              }
            }
            else {
              $dimmer = module.create();
            }
            module.set.variation();
          }
        },

        initialize: function () {
          module.debug('Initializing dimmer', settings);

          module.bind.events();
          module.set.dimmable();
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, instance)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous module', $dimmer);
          module.unbind.events();
          module.remove.variation();
          $dimmable
          .off(eventNamespace)
          ;
        },

        bind: {
          events: function () {
            if (settings.on == 'hover') {
              $dimmable
              .on('mouseenter' + eventNamespace, module.show)
              .on('mouseleave' + eventNamespace, module.hide)
              ;
            }
            else if (settings.on == 'click') {
              $dimmable
              .on(clickEvent + eventNamespace, module.toggle)
              ;
            }
            if (module.is.page()) {
              module.debug('Setting as a page dimmer', $dimmable);
              module.set.pageDimmer();
            }

            if (module.is.closable()) {
              module.verbose('Adding dimmer close event', $dimmer);
              $dimmable
              .on(clickEvent + eventNamespace, selector.dimmer,
                  module.event.click)
              ;
            }
          }
        },

        unbind: {
          events: function () {
            $module
            .removeData(moduleNamespace)
            ;
            $dimmable
            .off(eventNamespace)
            ;
          }
        },

        event: {
          click: function (event) {
            module.verbose('Determining if event occured on dimmer', event);
            if ($dimmer.find(event.target).length === 0 || $(event.target).is(
                    selector.content)) {
              module.hide();
              event.stopImmediatePropagation();
            }
          }
        },

        addContent: function (element) {
          var
              $content = $(element)
          ;
          module.debug('Add content to dimmer', $content);
          if ($content.parent()[0] !== $dimmer[0]) {
            $content.detach().appendTo($dimmer);
          }
        },

        create: function () {
          var
              $element = $(settings.template.dimmer())
          ;
          if (settings.dimmerName) {
            module.debug('Creating named dimmer', settings.dimmerName);
            $element.addClass(settings.dimmerName);
          }
          $element
          .appendTo($dimmable)
          ;
          return $element;
        },

        show: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          module.debug('Showing dimmer', $dimmer, settings);
          if ((!module.is.dimmed() || module.is.animating())
              && module.is.enabled()) {
            module.animate.show(callback);
            settings.onShow.call(element);
            settings.onChange.call(element);
          }
          else {
            module.debug('Dimmer is already shown or disabled');
          }
        },

        hide: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (module.is.dimmed() || module.is.animating()) {
            module.debug('Hiding dimmer', $dimmer);
            module.animate.hide(callback);
            settings.onHide.call(element);
            settings.onChange.call(element);
          }
          else {
            module.debug('Dimmer is not visible');
          }
        },

        toggle: function () {
          module.verbose('Toggling dimmer visibility', $dimmer);
          if (!module.is.dimmed()) {
            module.show();
          }
          else {
            module.hide();
          }
        },

        animate: {
          show: function (callback) {
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            if (settings.useCSS && $.fn.transition !== undefined
                && $dimmer.transition('is supported')) {
              if (settings.opacity !== 'auto') {
                module.set.opacity();
              }
              $dimmer
              .transition({
                animation: settings.transition + ' in',
                queue: false,
                duration: module.get.duration(),
                useFailSafe: true,
                onStart: function () {
                  module.set.dimmed();
                },
                onComplete: function () {
                  module.set.active();
                  callback();
                }
              })
              ;
            }
            else {
              module.verbose('Showing dimmer animation with javascript');
              module.set.dimmed();
              if (settings.opacity == 'auto') {
                settings.opacity = 0.8;
              }
              $dimmer
              .stop()
              .css({
                opacity: 0,
                width: '100%',
                height: '100%'
              })
              .fadeTo(module.get.duration(), settings.opacity, function () {
                $dimmer.removeAttr('style');
                module.set.active();
                callback();
              })
              ;
            }
          },
          hide: function (callback) {
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            if (settings.useCSS && $.fn.transition !== undefined
                && $dimmer.transition('is supported')) {
              module.verbose('Hiding dimmer with css');
              $dimmer
              .transition({
                animation: settings.transition + ' out',
                queue: false,
                duration: module.get.duration(),
                useFailSafe: true,
                onStart: function () {
                  module.remove.dimmed();
                },
                onComplete: function () {
                  module.remove.active();
                  callback();
                }
              })
              ;
            }
            else {
              module.verbose('Hiding dimmer with javascript');
              module.remove.dimmed();
              $dimmer
              .stop()
              .fadeOut(module.get.duration(), function () {
                module.remove.active();
                $dimmer.removeAttr('style');
                callback();
              })
              ;
            }
          }
        },

        get: {
          dimmer: function () {
            return $dimmer;
          },
          duration: function () {
            if (typeof settings.duration == 'object') {
              if (module.is.active()) {
                return settings.duration.hide;
              }
              else {
                return settings.duration.show;
              }
            }
            return settings.duration;
          }
        },

        has: {
          dimmer: function () {
            if (settings.dimmerName) {
              return ($module.find(selector.dimmer).filter(
                  '.' + settings.dimmerName).length > 0);
            }
            else {
              return ( $module.find(selector.dimmer).length > 0 );
            }
          }
        },

        is: {
          active: function () {
            return $dimmer.hasClass(className.active);
          },
          animating: function () {
            return ( $dimmer.is(':animated') || $dimmer.hasClass(
                className.animating) );
          },
          closable: function () {
            if (settings.closable == 'auto') {
              if (settings.on == 'hover') {
                return false;
              }
              return true;
            }
            return settings.closable;
          },
          dimmer: function () {
            return $module.hasClass(className.dimmer);
          },
          dimmable: function () {
            return $module.hasClass(className.dimmable);
          },
          dimmed: function () {
            return $dimmable.hasClass(className.dimmed);
          },
          disabled: function () {
            return $dimmable.hasClass(className.disabled);
          },
          enabled: function () {
            return !module.is.disabled();
          },
          page: function () {
            return $dimmable.is('body');
          },
          pageDimmer: function () {
            return $dimmer.hasClass(className.pageDimmer);
          }
        },

        can: {
          show: function () {
            return !$dimmer.hasClass(className.disabled);
          }
        },

        set: {
          opacity: function (opacity) {
            var
                color = $dimmer.css('background-color'),
                colorArray = color.split(','),
                isRGB = (colorArray && colorArray.length == 3),
                isRGBA = (colorArray && colorArray.length == 4)
            ;
            opacity = settings.opacity === 0 ? 0 : settings.opacity || opacity;
            if (isRGB || isRGBA) {
              colorArray[3] = opacity + ')';
              color = colorArray.join(',');
            }
            else {
              color = 'rgba(0, 0, 0, ' + opacity + ')';
            }
            module.debug('Setting opacity to', opacity);
            $dimmer.css('background-color', color);
          },
          active: function () {
            $dimmer.addClass(className.active);
          },
          dimmable: function () {
            $dimmable.addClass(className.dimmable);
          },
          dimmed: function () {
            $dimmable.addClass(className.dimmed);
          },
          pageDimmer: function () {
            $dimmer.addClass(className.pageDimmer);
          },
          disabled: function () {
            $dimmer.addClass(className.disabled);
          },
          variation: function (variation) {
            variation = variation || settings.variation;
            if (variation) {
              $dimmer.addClass(variation);
            }
          }
        },

        remove: {
          active: function () {
            $dimmer
            .removeClass(className.active)
            ;
          },
          dimmed: function () {
            $dimmable.removeClass(className.dimmed);
          },
          disabled: function () {
            $dimmer.removeClass(className.disabled);
          },
          variation: function (variation) {
            variation = variation || settings.variation;
            if (variation) {
              $dimmer.removeClass(variation);
            }
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      module.preinitialize();

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.dimmer.settings = {

    name: 'Dimmer',
    namespace: 'dimmer',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    // name to distinguish between multiple dimmers in context
    dimmerName: false,

    // whether to add a variation type
    variation: false,

    // whether to bind close events
    closable: 'auto',

    // whether to use css animations
    useCSS: true,

    // css animation to use
    transition: 'fade',

    // event to bind to
    on: false,

    // overriding opacity value
    opacity: 'auto',

    // transition durations
    duration: {
      show: 500,
      hide: 500
    },

    onChange: function () {
    },
    onShow: function () {
    },
    onHide: function () {
    },

    error: {
      method: 'The method you called is not defined.'
    },

    className: {
      active: 'active',
      animating: 'animating',
      dimmable: 'dimmable',
      dimmed: 'dimmed',
      dimmer: 'dimmer',
      disabled: 'disabled',
      hide: 'hide',
      pageDimmer: 'page',
      show: 'show'
    },

    selector: {
      dimmer: '> .ui.dimmer',
      content: '.ui.dimmer > .content, .ui.dimmer > .content > .center'
    },

    template: {
      dimmer: function () {
        return $('<div />').attr('class', 'ui dimmer');
      }
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Dropdown
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.dropdown = function (parameters) {
    var
        $allModules = $(this),
        $document = $(document),

        moduleSelector = $allModules.selector || '',

        hasTouch = ('ontouchstart' in document.documentElement),
        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;

    $allModules
    .each(function (elementIndex) {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.dropdown.settings, parameters)
              : $.extend({}, $.fn.dropdown.settings),

          className = settings.className,
          message = settings.message,
          fields = settings.fields,
          keys = settings.keys,
          metadata = settings.metadata,
          namespace = settings.namespace,
          regExp = settings.regExp,
          selector = settings.selector,
          error = settings.error,
          templates = settings.templates,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $context = $(settings.context),
          $text = $module.find(selector.text),
          $search = $module.find(selector.search),
          $sizer = $module.find(selector.sizer),
          $input = $module.find(selector.input),
          $icon = $module.find(selector.icon),

          $combo = ($module.prev().find(selector.text).length > 0)
              ? $module.prev().find(selector.text)
              : $module.prev(),

          $menu = $module.children(selector.menu),
          $item = $menu.find(selector.item),

          activated = false,
          itemActivated = false,
          internalChange = false,
          element = this,
          instance = $module.data(moduleNamespace),

          initialLoad,
          pageLostFocus,
          willRefocus,
          elementNamespace,
          id,
          selectObserver,
          menuObserver,
          module
      ;

      module = {

        initialize: function () {
          module.debug('Initializing dropdown', settings);

          if (module.is.alreadySetup()) {
            module.setup.reference();
          }
          else {
            module.setup.layout();
            module.refreshData();

            module.save.defaults();
            module.restore.selected();

            module.create.id();
            module.bind.events();

            module.observeChanges();
            module.instantiate();
          }

        },

        instantiate: function () {
          module.verbose('Storing instance of dropdown', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous dropdown', $module);
          module.remove.tabbable();
          $module
          .off(eventNamespace)
          .removeData(moduleNamespace)
          ;
          $menu
          .off(eventNamespace)
          ;
          $document
          .off(elementNamespace)
          ;
          module.disconnect.menuObserver();
          module.disconnect.selectObserver();
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            selectObserver = new MutationObserver(module.event.select.mutation);
            menuObserver = new MutationObserver(module.event.menu.mutation);
            module.debug('Setting up mutation observer', selectObserver,
                menuObserver);
            module.observe.select();
            module.observe.menu();
          }
        },

        disconnect: {
          menuObserver: function () {
            if (menuObserver) {
              menuObserver.disconnect();
            }
          },
          selectObserver: function () {
            if (selectObserver) {
              selectObserver.disconnect();
            }
          }
        },
        observe: {
          select: function () {
            if (module.has.input()) {
              selectObserver.observe($input[0], {
                childList: true,
                subtree: true
              });
            }
          },
          menu: function () {
            if (module.has.menu()) {
              menuObserver.observe($menu[0], {
                childList: true,
                subtree: true
              });
            }
          }
        },

        create: {
          id: function () {
            id = (Math.random().toString(16) + '000000000').substr(2, 8);
            elementNamespace = '.' + id;
            module.verbose('Creating unique id for element', id);
          },
          userChoice: function (values) {
            var
                $userChoices,
                $userChoice,
                isUserValue,
                html
            ;
            values = values || module.get.userValues();
            if (!values) {
              return false;
            }
            values = $.isArray(values)
                ? values
                : [values]
            ;
            $.each(values, function (index, value) {
              if (module.get.item(value) === false) {
                html = settings.templates.addition(
                    module.add.variables(message.addResult, value));
                $userChoice = $('<div />')
                .html(html)
                .attr('data-' + metadata.value, value)
                .attr('data-' + metadata.text, value)
                .addClass(className.addition)
                .addClass(className.item)
                ;
                if (settings.hideAdditions) {
                  $userChoice.addClass(className.hidden);
                }
                $userChoices = ($userChoices === undefined)
                    ? $userChoice
                    : $userChoices.add($userChoice)
                ;
                module.verbose('Creating user choices for value', value,
                    $userChoice);
              }
            });
            return $userChoices;
          },
          userLabels: function (value) {
            var
                userValues = module.get.userValues()
            ;
            if (userValues) {
              module.debug('Adding user labels', userValues);
              $.each(userValues, function (index, value) {
                module.verbose('Adding custom user value');
                module.add.label(value, value);
              });
            }
          },
          menu: function () {
            $menu = $('<div />')
            .addClass(className.menu)
            .appendTo($module)
            ;
          },
          sizer: function () {
            $sizer = $('<span />')
            .addClass(className.sizer)
            .insertAfter($search)
            ;
          }
        },

        search: function (query) {
          query = (query !== undefined)
              ? query
              : module.get.query()
          ;
          module.verbose('Searching for query', query);
          if (module.has.minCharacters(query)) {
            module.filter(query);
          }
          else {
            module.hide();
          }
        },

        select: {
          firstUnfiltered: function () {
            module.verbose('Selecting first non-filtered element');
            module.remove.selectedItem();
            $item
            .not(selector.unselectable)
            .not(selector.addition + selector.hidden)
            .eq(0)
            .addClass(className.selected)
            ;
          },
          nextAvailable: function ($selected) {
            $selected = $selected.eq(0);
            var
                $nextAvailable = $selected.nextAll(selector.item).not(
                    selector.unselectable).eq(0),
                $prevAvailable = $selected.prevAll(selector.item).not(
                    selector.unselectable).eq(0),
                hasNext = ($nextAvailable.length > 0)
            ;
            if (hasNext) {
              module.verbose('Moving selection to', $nextAvailable);
              $nextAvailable.addClass(className.selected);
            }
            else {
              module.verbose('Moving selection to', $prevAvailable);
              $prevAvailable.addClass(className.selected);
            }
          }
        },

        setup: {
          api: function () {
            var
                apiSettings = {
                  debug: settings.debug,
                  urlData: {
                    value: module.get.value(),
                    query: module.get.query()
                  },
                  on: false
                }
            ;
            module.verbose('First request, initializing API');
            $module
            .api(apiSettings)
            ;
          },
          layout: function () {
            if ($module.is('select')) {
              module.setup.select();
              module.setup.returnedObject();
            }
            if (!module.has.menu()) {
              module.create.menu();
            }
            if (module.is.search() && !module.has.search()) {
              module.verbose('Adding search input');
              $search = $('<input />')
              .addClass(className.search)
              .prop('autocomplete', 'off')
              .insertBefore($text)
              ;
            }
            if (module.is.multiple() && module.is.searchSelection()
                && !module.has.sizer()) {
              module.create.sizer();
            }
            if (settings.allowTab) {
              module.set.tabbable();
            }
          },
          select: function () {
            var
                selectValues = module.get.selectValues()
            ;
            module.debug('Dropdown initialized on a select', selectValues);
            if ($module.is('select')) {
              $input = $module;
            }
            // see if select is placed correctly already
            if ($input.parent(selector.dropdown).length > 0) {
              module.debug(
                  'UI dropdown already exists. Creating dropdown menu only');
              $module = $input.closest(selector.dropdown);
              if (!module.has.menu()) {
                module.create.menu();
              }
              $menu = $module.children(selector.menu);
              module.setup.menu(selectValues);
            }
            else {
              module.debug('Creating entire dropdown from select');
              $module = $('<div />')
              .attr('class', $input.attr('class'))
              .addClass(className.selection)
              .addClass(className.dropdown)
              .html(templates.dropdown(selectValues))
              .insertBefore($input)
              ;
              if ($input.hasClass(className.multiple) && $input.prop('multiple')
                  === false) {
                module.error(error.missingMultiple);
                $input.prop('multiple', true);
              }
              if ($input.is('[multiple]')) {
                module.set.multiple();
              }
              if ($input.prop('disabled')) {
                module.debug('Disabling dropdown');
                $module.addClass(className.disabled);
              }
              $input
              .removeAttr('class')
              .detach()
              .prependTo($module)
              ;
            }
            module.refresh();
          },
          menu: function (values) {
            $menu.html(templates.menu(values, fields));
            $item = $menu.find(selector.item);
          },
          reference: function () {
            module.debug(
                'Dropdown behavior was called on select, replacing with closest dropdown');
            // replace module reference
            $module = $module.parent(selector.dropdown);
            module.refresh();
            module.setup.returnedObject();
            // invoke method in context of current instance
            if (methodInvoked) {
              instance = module;
              module.invoke(query);
            }
          },
          returnedObject: function () {
            var
                $firstModules = $allModules.slice(0, elementIndex),
                $lastModules = $allModules.slice(elementIndex + 1)
            ;
            // adjust all modules to use correct reference
            $allModules = $firstModules.add($module).add($lastModules);
          }
        },

        refresh: function () {
          module.refreshSelectors();
          module.refreshData();
        },

        refreshItems: function () {
          $item = $menu.find(selector.item);
        },

        refreshSelectors: function () {
          module.verbose('Refreshing selector cache');
          $text = $module.find(selector.text);
          $search = $module.find(selector.search);
          $input = $module.find(selector.input);
          $icon = $module.find(selector.icon);
          $combo = ($module.prev().find(selector.text).length > 0)
              ? $module.prev().find(selector.text)
              : $module.prev()
          ;
          $menu = $module.children(selector.menu);
          $item = $menu.find(selector.item);
        },

        refreshData: function () {
          module.verbose('Refreshing cached metadata');
          $item
          .removeData(metadata.text)
          .removeData(metadata.value)
          ;
        },

        clearData: function () {
          module.verbose('Clearing metadata');
          $item
          .removeData(metadata.text)
          .removeData(metadata.value)
          ;
          $module
          .removeData(metadata.defaultText)
          .removeData(metadata.defaultValue)
          .removeData(metadata.placeholderText)
          ;
        },

        toggle: function () {
          module.verbose('Toggling menu visibility');
          if (!module.is.active()) {
            module.show();
          }
          else {
            module.hide();
          }
        },

        show: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (!module.can.show() && module.is.remote()) {
            module.debug('No API results retrieved, searching before show');
            module.queryRemote(module.get.query(), module.show);
          }
          if (module.can.show() && !module.is.active()) {
            module.debug('Showing dropdown');
            if (module.has.message() && !(module.has.maxSelections()
                || module.has.allResultsFiltered())) {
              module.remove.message();
            }
            if (module.is.allFiltered()) {
              return true;
            }
            if (settings.onShow.call(element) !== false) {
              module.animate.show(function () {
                if (module.can.click()) {
                  module.bind.intent();
                }
                if (module.has.menuSearch()) {
                  module.focusSearch();
                }
                module.set.visible();
                callback.call(element);
              });
            }
          }
        },

        hide: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (module.is.active()) {
            module.debug('Hiding dropdown');
            if (settings.onHide.call(element) !== false) {
              module.animate.hide(function () {
                module.remove.visible();
                callback.call(element);
              });
            }
          }
        },

        hideOthers: function () {
          module.verbose('Finding other dropdowns to hide');
          $allModules
          .not($module)
          .has(selector.menu + '.' + className.visible)
          .dropdown('hide')
          ;
        },

        hideMenu: function () {
          module.verbose('Hiding menu  instantaneously');
          module.remove.active();
          module.remove.visible();
          $menu.transition('hide');
        },

        hideSubMenus: function () {
          var
              $subMenus = $menu.children(selector.item).find(selector.menu)
          ;
          module.verbose('Hiding sub menus', $subMenus);
          $subMenus.transition('hide');
        },

        bind: {
          events: function () {
            if (hasTouch) {
              module.bind.touchEvents();
            }
            module.bind.keyboardEvents();
            module.bind.inputEvents();
            module.bind.mouseEvents();
          },
          touchEvents: function () {
            module.debug(
                'Touch device detected binding additional touch events');
            if (module.is.searchSelection()) {
              // do nothing special yet
            }
            else if (module.is.single()) {
              $module
              .on('touchstart' + eventNamespace, module.event.test.toggle)
              ;
            }
            $menu
            .on('touchstart' + eventNamespace, selector.item,
                module.event.item.mouseenter)
            ;
          },
          keyboardEvents: function () {
            module.verbose('Binding keyboard events');
            $module
            .on('keydown' + eventNamespace, module.event.keydown)
            ;
            if (module.has.search()) {
              $module
              .on(module.get.inputEvent() + eventNamespace, selector.search,
                  module.event.input)
              ;
            }
            if (module.is.multiple()) {
              $document
              .on('keydown' + elementNamespace, module.event.document.keydown)
              ;
            }
          },
          inputEvents: function () {
            module.verbose('Binding input change events');
            $module
            .on('change' + eventNamespace, selector.input, module.event.change)
            ;
          },
          mouseEvents: function () {
            module.verbose('Binding mouse events');
            if (module.is.multiple()) {
              $module
              .on('click' + eventNamespace, selector.label,
                  module.event.label.click)
              .on('click' + eventNamespace, selector.remove,
                  module.event.remove.click)
              ;
            }
            if (module.is.searchSelection()) {
              $module
              .on('mousedown' + eventNamespace, module.event.mousedown)
              .on('mouseup' + eventNamespace, module.event.mouseup)
              .on('mousedown' + eventNamespace, selector.menu,
                  module.event.menu.mousedown)
              .on('mouseup' + eventNamespace, selector.menu,
                  module.event.menu.mouseup)
              .on('click' + eventNamespace, selector.icon,
                  module.event.icon.click)
              .on('focus' + eventNamespace, selector.search,
                  module.event.search.focus)
              .on('click' + eventNamespace, selector.search,
                  module.event.search.focus)
              .on('blur' + eventNamespace, selector.search,
                  module.event.search.blur)
              .on('click' + eventNamespace, selector.text,
                  module.event.text.focus)
              ;
              if (module.is.multiple()) {
                $module
                .on('click' + eventNamespace, module.event.click)
                ;
              }
            }
            else {
              if (settings.on == 'click') {
                $module
                .on('click' + eventNamespace, selector.icon,
                    module.event.icon.click)
                .on('click' + eventNamespace, module.event.test.toggle)
                ;
              }
              else if (settings.on == 'hover') {
                $module
                .on('mouseenter' + eventNamespace, module.delay.show)
                .on('mouseleave' + eventNamespace, module.delay.hide)
                ;
              }
              else {
                $module
                .on(settings.on + eventNamespace, module.toggle)
                ;
              }
              $module
              .on('mousedown' + eventNamespace, module.event.mousedown)
              .on('mouseup' + eventNamespace, module.event.mouseup)
              .on('focus' + eventNamespace, module.event.focus)
              ;
              if (module.has.menuSearch()) {
                $module
                .on('blur' + eventNamespace, selector.search,
                    module.event.search.blur)
                ;
              }
              else {
                $module
                .on('blur' + eventNamespace, module.event.blur)
                ;
              }
            }
            $menu
            .on('mouseenter' + eventNamespace, selector.item,
                module.event.item.mouseenter)
            .on('mouseleave' + eventNamespace, selector.item,
                module.event.item.mouseleave)
            .on('click' + eventNamespace, selector.item,
                module.event.item.click)
            ;
          },
          intent: function () {
            module.verbose('Binding hide intent event to document');
            if (hasTouch) {
              $document
              .on('touchstart' + elementNamespace, module.event.test.touch)
              .on('touchmove' + elementNamespace, module.event.test.touch)
              ;
            }
            $document
            .on('click' + elementNamespace, module.event.test.hide)
            ;
          }
        },

        unbind: {
          intent: function () {
            module.verbose('Removing hide intent event from document');
            if (hasTouch) {
              $document
              .off('touchstart' + elementNamespace)
              .off('touchmove' + elementNamespace)
              ;
            }
            $document
            .off('click' + elementNamespace)
            ;
          }
        },

        filter: function (query) {
          var
              searchTerm = (query !== undefined)
                  ? query
                  : module.get.query(),
              afterFiltered = function () {
                if (module.is.multiple()) {
                  module.filterActive();
                }
                module.select.firstUnfiltered();
                if (module.has.allResultsFiltered()) {
                  if (settings.onNoResults.call(element, searchTerm)) {
                    if (settings.allowAdditions) {
                      if (settings.hideAdditions) {
                        module.verbose(
                            'User addition with no menu, setting empty style');
                        module.set.empty();
                        module.hideMenu();
                      }
                    }
                    else {
                      module.verbose('All items filtered, showing message',
                          searchTerm);
                      module.add.message(message.noResults);
                    }
                  }
                  else {
                    module.verbose('All items filtered, hiding dropdown',
                        searchTerm);
                    module.hideMenu();
                  }
                }
                else {
                  module.remove.empty();
                  module.remove.message();
                }
                if (settings.allowAdditions) {
                  module.add.userSuggestion(query);
                }
                if (module.is.searchSelection() && module.can.show()
                    && module.is.focusedOnSearch()) {
                  module.show();
                }
              }
          ;
          if (settings.useLabels && module.has.maxSelections()) {
            return;
          }
          if (settings.apiSettings) {
            if (module.can.useAPI()) {
              module.queryRemote(searchTerm, function () {
                if (settings.filterRemoteData) {
                  module.filterItems(searchTerm);
                }
                afterFiltered();
              });
            }
            else {
              module.error(error.noAPI);
            }
          }
          else {
            module.filterItems(searchTerm);
            afterFiltered();
          }
        },

        queryRemote: function (query, callback) {
          var
              apiSettings = {
                errorDuration: false,
                cache: 'local',
                throttle: settings.throttle,
                urlData: {
                  query: query
                },
                onError: function () {
                  module.add.message(message.serverError);
                  callback();
                },
                onFailure: function () {
                  module.add.message(message.serverError);
                  callback();
                },
                onSuccess: function (response) {
                  module.remove.message();
                  module.setup.menu({
                    values: response[fields.remoteValues]
                  });
                  callback();
                }
              }
          ;
          if (!$module.api('get request')) {
            module.setup.api();
          }
          apiSettings = $.extend(true, {}, apiSettings, settings.apiSettings);
          $module
          .api('setting', apiSettings)
          .api('query')
          ;
        },

        filterItems: function (query) {
          var
              searchTerm = (query !== undefined)
                  ? query
                  : module.get.query(),
              results = null,
              escapedTerm = module.escape.string(searchTerm),
              beginsWithRegExp = new RegExp('^' + escapedTerm, 'igm')
          ;
          // avoid loop if we're matching nothing
          if (module.has.query()) {
            results = [];

            module.verbose('Searching for matching values', searchTerm);
            $item
            .each(function () {
              var
                  $choice = $(this),
                  text,
                  value
              ;
              if (settings.match == 'both' || settings.match == 'text') {
                text = String(module.get.choiceText($choice, false));
                if (text.search(beginsWithRegExp) !== -1) {
                  results.push(this);
                  return true;
                }
                else if (settings.fullTextSearch === 'exact'
                    && module.exactSearch(searchTerm, text)) {
                  results.push(this);
                  return true;
                }
                else if (settings.fullTextSearch === true && module.fuzzySearch(
                        searchTerm, text)) {
                  results.push(this);
                  return true;
                }
              }
              if (settings.match == 'both' || settings.match == 'value') {
                value = String(module.get.choiceValue($choice, text));
                if (value.search(beginsWithRegExp) !== -1) {
                  results.push(this);
                  return true;
                }
                else if (settings.fullTextSearch === 'exact'
                    && module.exactSearch(searchTerm, value)) {
                  results.push(this);
                  return true;
                }
                else if (settings.fullTextSearch === true && module.fuzzySearch(
                        searchTerm, value)) {
                  results.push(this);
                  return true;
                }
              }
            })
            ;
          }
          module.debug('Showing only matched items', searchTerm);
          module.remove.filteredItem();
          if (results) {
            $item
            .not(results)
            .addClass(className.filtered)
            ;
          }
        },

        fuzzySearch: function (query, term) {
          var
              termLength = term.length,
              queryLength = query.length
          ;
          query = query.toLowerCase();
          term = term.toLowerCase();
          if (queryLength > termLength) {
            return false;
          }
          if (queryLength === termLength) {
            return (query === term);
          }
          search: for (var characterIndex = 0, nextCharacterIndex = 0;
              characterIndex < queryLength; characterIndex++) {
            var
                queryCharacter = query.charCodeAt(characterIndex)
            ;
            while (nextCharacterIndex < termLength) {
              if (term.charCodeAt(nextCharacterIndex++) === queryCharacter) {
                continue search;
              }
            }
            return false;
          }
          return true;
        },
        exactSearch: function (query, term) {
          query = query.toLowerCase();
          term = term.toLowerCase();
          if (term.indexOf(query) > -1) {
            return true;
          }
          return false;
        },
        filterActive: function () {
          if (settings.useLabels) {
            $item.filter('.' + className.active)
            .addClass(className.filtered)
            ;
          }
        },

        focusSearch: function (skipHandler) {
          if (module.has.search() && !module.is.focusedOnSearch()) {
            if (skipHandler) {
              $module.off('focus' + eventNamespace, selector.search);
              $search.focus();
              $module.on('focus' + eventNamespace, selector.search,
                  module.event.search.focus);
            }
            else {
              $search.focus();
            }
          }
        },

        forceSelection: function () {
          var
              $currentlySelected = $item.not(className.filtered).filter(
                  '.' + className.selected).eq(0),
              $activeItem = $item.not(className.filtered).filter(
                  '.' + className.active).eq(0),
              $selectedItem = ($currentlySelected.length > 0)
                  ? $currentlySelected
                  : $activeItem,
              hasSelected = ($selectedItem.length > 0)
          ;
          if (hasSelected && !module.is.multiple()) {
            module.debug('Forcing partial selection to selected item',
                $selectedItem);
            module.event.item.click.call($selectedItem, {}, true);
            return;
          }
          else {
            if (settings.allowAdditions) {
              module.set.selected(module.get.query());
              module.remove.searchTerm();
            }
            else {
              module.remove.searchTerm();
            }
          }
        },

        event: {
          change: function () {
            if (!internalChange) {
              module.debug('Input changed, updating selection');
              module.set.selected();
            }
          },
          focus: function () {
            if (settings.showOnFocus && !activated && module.is.hidden()
                && !pageLostFocus) {
              module.show();
            }
          },
          blur: function (event) {
            pageLostFocus = (document.activeElement === this);
            if (!activated && !pageLostFocus) {
              module.remove.activeLabel();
              module.hide();
            }
          },
          mousedown: function () {
            if (module.is.searchSelection()) {
              // prevent menu hiding on immediate re-focus
              willRefocus = true;
            }
            else {
              // prevents focus callback from occurring on mousedown
              activated = true;
            }
          },
          mouseup: function () {
            if (module.is.searchSelection()) {
              // prevent menu hiding on immediate re-focus
              willRefocus = false;
            }
            else {
              activated = false;
            }
          },
          click: function (event) {
            var
                $target = $(event.target)
            ;
            // focus search
            if ($target.is($module)) {
              if (!module.is.focusedOnSearch()) {
                module.focusSearch();
              }
              else {
                module.show();
              }
            }
          },
          search: {
            focus: function () {
              activated = true;
              if (module.is.multiple()) {
                module.remove.activeLabel();
              }
              if (settings.showOnFocus) {
                module.search();
              }
            },
            blur: function (event) {
              pageLostFocus = (document.activeElement === this);
              if (module.is.searchSelection() && !willRefocus) {
                if (!itemActivated && !pageLostFocus) {
                  if (settings.forceSelection) {
                    module.forceSelection();
                  }
                  module.hide();
                }
              }
              willRefocus = false;
            }
          },
          icon: {
            click: function (event) {
              module.toggle();
            }
          },
          text: {
            focus: function (event) {
              activated = true;
              module.focusSearch();
            }
          },
          input: function (event) {
            if (module.is.multiple() || module.is.searchSelection()) {
              module.set.filtered();
            }
            clearTimeout(module.timer);
            module.timer = setTimeout(module.search, settings.delay.search);
          },
          label: {
            click: function (event) {
              var
                  $label = $(this),
                  $labels = $module.find(selector.label),
                  $activeLabels = $labels.filter('.' + className.active),
                  $nextActive = $label.nextAll('.' + className.active),
                  $prevActive = $label.prevAll('.' + className.active),
                  $range = ($nextActive.length > 0)
                      ? $label.nextUntil($nextActive).add($activeLabels).add(
                          $label)
                      : $label.prevUntil($prevActive).add($activeLabels).add(
                          $label)
              ;
              if (event.shiftKey) {
                $activeLabels.removeClass(className.active);
                $range.addClass(className.active);
              }
              else if (event.ctrlKey) {
                $label.toggleClass(className.active);
              }
              else {
                $activeLabels.removeClass(className.active);
                $label.addClass(className.active);
              }
              settings.onLabelSelect.apply(this,
                  $labels.filter('.' + className.active));
            }
          },
          remove: {
            click: function () {
              var
                  $label = $(this).parent()
              ;
              if ($label.hasClass(className.active)) {
                // remove all selected labels
                module.remove.activeLabels();
              }
              else {
                // remove this label only
                module.remove.activeLabels($label);
              }
            }
          },
          test: {
            toggle: function (event) {
              var
                  toggleBehavior = (module.is.multiple())
                      ? module.show
                      : module.toggle
              ;
              if (module.is.bubbledLabelClick(event)
                  || module.is.bubbledIconClick(event)) {
                return;
              }
              if (module.determine.eventOnElement(event, toggleBehavior)) {
                event.preventDefault();
              }
            },
            touch: function (event) {
              module.determine.eventOnElement(event, function () {
                if (event.type == 'touchstart') {
                  module.timer = setTimeout(function () {
                    module.hide();
                  }, settings.delay.touch);
                }
                else if (event.type == 'touchmove') {
                  clearTimeout(module.timer);
                }
              });
              event.stopPropagation();
            },
            hide: function (event) {
              module.determine.eventInModule(event, module.hide);
            }
          },
          select: {
            mutation: function (mutations) {
              module.debug('<select> modified, recreating menu');
              module.setup.select();
            }
          },
          menu: {
            mutation: function (mutations) {
              var
                  mutation = mutations[0],
                  $addedNode = mutation.addedNodes
                      ? $(mutation.addedNodes[0])
                      : $(false),
                  $removedNode = mutation.removedNodes
                      ? $(mutation.removedNodes[0])
                      : $(false),
                  $changedNodes = $addedNode.add($removedNode),
                  isUserAddition = $changedNodes.is(selector.addition)
                      || $changedNodes.closest(selector.addition).length > 0,
                  isMessage = $changedNodes.is(selector.message)
                      || $changedNodes.closest(selector.message).length > 0
              ;
              if (isUserAddition || isMessage) {
                module.debug('Updating item selector cache');
                module.refreshItems();
              }
              else {
                module.debug('Menu modified, updating selector cache');
                module.refresh();
              }
            },
            mousedown: function () {
              itemActivated = true;
            },
            mouseup: function () {
              itemActivated = false;
            }
          },
          item: {
            mouseenter: function (event) {
              var
                  $target = $(event.target),
                  $item = $(this),
                  $subMenu = $item.children(selector.menu),
                  $otherMenus = $item.siblings(selector.item).children(
                      selector.menu),
                  hasSubMenu = ($subMenu.length > 0),
                  isBubbledEvent = ($subMenu.find($target).length > 0)
              ;
              if (!isBubbledEvent && hasSubMenu) {
                clearTimeout(module.itemTimer);
                module.itemTimer = setTimeout(function () {
                  module.verbose('Showing sub-menu', $subMenu);
                  $.each($otherMenus, function () {
                    module.animate.hide(false, $(this));
                  });
                  module.animate.show(false, $subMenu);
                }, settings.delay.show);
                event.preventDefault();
              }
            },
            mouseleave: function (event) {
              var
                  $subMenu = $(this).children(selector.menu)
              ;
              if ($subMenu.length > 0) {
                clearTimeout(module.itemTimer);
                module.itemTimer = setTimeout(function () {
                  module.verbose('Hiding sub-menu', $subMenu);
                  module.animate.hide(false, $subMenu);
                }, settings.delay.hide);
              }
            },
            click: function (event, skipRefocus) {
              var
                  $choice = $(this),
                  $target = (event)
                      ? $(event.target)
                      : $(''),
                  $subMenu = $choice.find(selector.menu),
                  text = module.get.choiceText($choice),
                  value = module.get.choiceValue($choice, text),
                  hasSubMenu = ($subMenu.length > 0),
                  isBubbledEvent = ($subMenu.find($target).length > 0)
              ;
              // prevents IE11 bug where menu receives focus even though `tabindex=-1`
              if (module.has.menuSearch()) {
                $(document.activeElement).blur();
              }
              if (!isBubbledEvent && (!hasSubMenu
                  || settings.allowCategorySelection)) {
                if (module.is.searchSelection()) {
                  if (settings.allowAdditions) {
                    module.remove.userAddition();
                  }
                  module.remove.searchTerm();
                  if (!module.is.focusedOnSearch() && !(skipRefocus == true)) {
                    module.focusSearch(true);
                  }
                }
                if (!settings.useLabels) {
                  module.remove.filteredItem();
                  module.set.scrollPosition($choice);
                }
                module.determine.selectAction.call(this, text, value);
              }
            }
          },

          document: {
            // label selection should occur even when element has no focus
            keydown: function (event) {
              var
                  pressedKey = event.which,
                  isShortcutKey = module.is.inObject(pressedKey, keys)
              ;
              if (isShortcutKey) {
                var
                    $label = $module.find(selector.label),
                    $activeLabel = $label.filter('.' + className.active),
                    activeValue = $activeLabel.data(metadata.value),
                    labelIndex = $label.index($activeLabel),
                    labelCount = $label.length,
                    hasActiveLabel = ($activeLabel.length > 0),
                    hasMultipleActive = ($activeLabel.length > 1),
                    isFirstLabel = (labelIndex === 0),
                    isLastLabel = (labelIndex + 1 == labelCount),
                    isSearch = module.is.searchSelection(),
                    isFocusedOnSearch = module.is.focusedOnSearch(),
                    isFocused = module.is.focused(),
                    caretAtStart = (isFocusedOnSearch
                    && module.get.caretPosition() === 0),
                    $nextLabel
                ;
                if (isSearch && !hasActiveLabel && !isFocusedOnSearch) {
                  return;
                }

                if (pressedKey == keys.leftArrow) {
                  // activate previous label
                  if ((isFocused || caretAtStart) && !hasActiveLabel) {
                    module.verbose('Selecting previous label');
                    $label.last().addClass(className.active);
                  }
                  else if (hasActiveLabel) {
                    if (!event.shiftKey) {
                      module.verbose('Selecting previous label');
                      $label.removeClass(className.active);
                    }
                    else {
                      module.verbose('Adding previous label to selection');
                    }
                    if (isFirstLabel && !hasMultipleActive) {
                      $activeLabel.addClass(className.active);
                    }
                    else {
                      $activeLabel.prev(selector.siblingLabel)
                      .addClass(className.active)
                      .end()
                      ;
                    }
                    event.preventDefault();
                  }
                }
                else if (pressedKey == keys.rightArrow) {
                  // activate first label
                  if (isFocused && !hasActiveLabel) {
                    $label.first().addClass(className.active);
                  }
                  // activate next label
                  if (hasActiveLabel) {
                    if (!event.shiftKey) {
                      module.verbose('Selecting next label');
                      $label.removeClass(className.active);
                    }
                    else {
                      module.verbose('Adding next label to selection');
                    }
                    if (isLastLabel) {
                      if (isSearch) {
                        if (!isFocusedOnSearch) {
                          module.focusSearch();
                        }
                        else {
                          $label.removeClass(className.active);
                        }
                      }
                      else if (hasMultipleActive) {
                        $activeLabel.next(selector.siblingLabel).addClass(
                            className.active);
                      }
                      else {
                        $activeLabel.addClass(className.active);
                      }
                    }
                    else {
                      $activeLabel.next(selector.siblingLabel).addClass(
                          className.active);
                    }
                    event.preventDefault();
                  }
                }
                else if (pressedKey == keys.deleteKey || pressedKey
                    == keys.backspace) {
                  if (hasActiveLabel) {
                    module.verbose('Removing active labels');
                    if (isLastLabel) {
                      if (isSearch && !isFocusedOnSearch) {
                        module.focusSearch();
                      }
                    }
                    $activeLabel.last().next(selector.siblingLabel).addClass(
                        className.active);
                    module.remove.activeLabels($activeLabel);
                    event.preventDefault();
                  }
                  else if (caretAtStart && !hasActiveLabel && pressedKey
                      == keys.backspace) {
                    module.verbose('Removing last label on input backspace');
                    $activeLabel = $label.last().addClass(className.active);
                    module.remove.activeLabels($activeLabel);
                  }
                }
                else {
                  $activeLabel.removeClass(className.active);
                }
              }
            }
          },

          keydown: function (event) {
            var
                pressedKey = event.which,
                isShortcutKey = module.is.inObject(pressedKey, keys)
            ;
            if (isShortcutKey) {
              var
                  $currentlySelected = $item.not(selector.unselectable).filter(
                      '.' + className.selected).eq(0),
                  $activeItem = $menu.children('.' + className.active).eq(0),
                  $selectedItem = ($currentlySelected.length > 0)
                      ? $currentlySelected
                      : $activeItem,
                  $visibleItems = ($selectedItem.length > 0)
                      ? $selectedItem.siblings(
                          ':not(.' + className.filtered + ')').addBack()
                      : $menu.children(':not(.' + className.filtered + ')'),
                  $subMenu = $selectedItem.children(selector.menu),
                  $parentMenu = $selectedItem.closest(selector.menu),
                  inVisibleMenu = ($parentMenu.hasClass(className.visible)
                  || $parentMenu.hasClass(className.animating)
                  || $parentMenu.parent(selector.menu).length > 0),
                  hasSubMenu = ($subMenu.length > 0),
                  hasSelectedItem = ($selectedItem.length > 0),
                  selectedIsSelectable = ($selectedItem.not(
                      selector.unselectable).length > 0),
                  delimiterPressed = (pressedKey == keys.delimiter
                  && settings.allowAdditions && module.is.multiple()),
                  isAdditionWithoutMenu = (settings.allowAdditions
                  && settings.hideAdditions && (pressedKey == keys.enter
                  || delimiterPressed) && selectedIsSelectable),
                  $nextItem,
                  isSubMenuItem,
                  newIndex
              ;
              // allow selection with menu closed
              if (isAdditionWithoutMenu) {
                module.verbose('Selecting item from keyboard shortcut',
                    $selectedItem);
                module.event.item.click.call($selectedItem, event);
                if (module.is.searchSelection()) {
                  module.remove.searchTerm();
                }
              }

              // visible menu keyboard shortcuts
              if (module.is.visible()) {

                // enter (select or open sub-menu)
                if (pressedKey == keys.enter || delimiterPressed) {
                  if (pressedKey == keys.enter && hasSelectedItem && hasSubMenu
                      && !settings.allowCategorySelection) {
                    module.verbose(
                        'Pressed enter on unselectable category, opening sub menu');
                    pressedKey = keys.rightArrow;
                  }
                  else if (selectedIsSelectable) {
                    module.verbose('Selecting item from keyboard shortcut',
                        $selectedItem);
                    module.event.item.click.call($selectedItem, event);
                    if (module.is.searchSelection()) {
                      module.remove.searchTerm();
                    }
                  }
                  event.preventDefault();
                }

                // sub-menu actions
                if (hasSelectedItem) {

                  if (pressedKey == keys.leftArrow) {

                    isSubMenuItem = ($parentMenu[0] !== $menu[0]);

                    if (isSubMenuItem) {
                      module.verbose('Left key pressed, closing sub-menu');
                      module.animate.hide(false, $parentMenu);
                      $selectedItem
                      .removeClass(className.selected)
                      ;
                      $parentMenu
                      .closest(selector.item)
                      .addClass(className.selected)
                      ;
                      event.preventDefault();
                    }
                  }

                  // right arrow (show sub-menu)
                  if (pressedKey == keys.rightArrow) {
                    if (hasSubMenu) {
                      module.verbose('Right key pressed, opening sub-menu');
                      module.animate.show(false, $subMenu);
                      $selectedItem
                      .removeClass(className.selected)
                      ;
                      $subMenu
                      .find(selector.item).eq(0)
                      .addClass(className.selected)
                      ;
                      event.preventDefault();
                    }
                  }
                }

                // up arrow (traverse menu up)
                if (pressedKey == keys.upArrow) {
                  $nextItem = (hasSelectedItem && inVisibleMenu)
                      ? $selectedItem.prevAll(
                          selector.item + ':not(' + selector.unselectable
                          + ')').eq(0)
                      : $item.eq(0)
                  ;
                  if ($visibleItems.index($nextItem) < 0) {
                    module.verbose(
                        'Up key pressed but reached top of current menu');
                    event.preventDefault();
                    return;
                  }
                  else {
                    module.verbose('Up key pressed, changing active item');
                    $selectedItem
                    .removeClass(className.selected)
                    ;
                    $nextItem
                    .addClass(className.selected)
                    ;
                    module.set.scrollPosition($nextItem);
                    if (settings.selectOnKeydown && module.is.single()) {
                      module.set.selectedItem($nextItem);
                    }
                  }
                  event.preventDefault();
                }

                // down arrow (traverse menu down)
                if (pressedKey == keys.downArrow) {
                  $nextItem = (hasSelectedItem && inVisibleMenu)
                      ? $nextItem = $selectedItem.nextAll(
                          selector.item + ':not(' + selector.unselectable
                          + ')').eq(0)
                      : $item.eq(0)
                  ;
                  if ($nextItem.length === 0) {
                    module.verbose(
                        'Down key pressed but reached bottom of current menu');
                    event.preventDefault();
                    return;
                  }
                  else {
                    module.verbose('Down key pressed, changing active item');
                    $item
                    .removeClass(className.selected)
                    ;
                    $nextItem
                    .addClass(className.selected)
                    ;
                    module.set.scrollPosition($nextItem);
                    if (settings.selectOnKeydown && module.is.single()) {
                      module.set.selectedItem($nextItem);
                    }
                  }
                  event.preventDefault();
                }

                // page down (show next page)
                if (pressedKey == keys.pageUp) {
                  module.scrollPage('up');
                  event.preventDefault();
                }
                if (pressedKey == keys.pageDown) {
                  module.scrollPage('down');
                  event.preventDefault();
                }

                // escape (close menu)
                if (pressedKey == keys.escape) {
                  module.verbose('Escape key pressed, closing dropdown');
                  module.hide();
                }

              }
              else {
                // delimiter key
                if (delimiterPressed) {
                  event.preventDefault();
                }
                // down arrow (open menu)
                if (pressedKey == keys.downArrow && !module.is.visible()) {
                  module.verbose('Down key pressed, showing dropdown');
                  module.select.firstUnfiltered();
                  module.show();
                  event.preventDefault();
                }
              }
            }
            else {
              if (!module.has.search()) {
                module.set.selectedLetter(String.fromCharCode(pressedKey));
              }
            }
          }
        },

        trigger: {
          change: function () {
            var
                events = document.createEvent('HTMLEvents'),
                inputElement = $input[0]
            ;
            if (inputElement) {
              module.verbose('Triggering native change event');
              events.initEvent('change', true, false);
              inputElement.dispatchEvent(events);
            }
          }
        },

        determine: {
          selectAction: function (text, value) {
            module.verbose('Determining action', settings.action);
            if ($.isFunction(module.action[settings.action])) {
              module.verbose('Triggering preset action', settings.action, text,
                  value);
              module.action[settings.action].call(element, text, value, this);
            }
            else if ($.isFunction(settings.action)) {
              module.verbose('Triggering user action', settings.action, text,
                  value);
              settings.action.call(element, text, value, this);
            }
            else {
              module.error(error.action, settings.action);
            }
          },
          eventInModule: function (event, callback) {
            var
                $target = $(event.target),
                inDocument = ($target.closest(document.documentElement).length
                > 0),
                inModule = ($target.closest($module).length > 0)
            ;
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            if (inDocument && !inModule) {
              module.verbose('Triggering event', callback);
              callback();
              return true;
            }
            else {
              module.verbose('Event occurred in dropdown, canceling callback');
              return false;
            }
          },
          eventOnElement: function (event, callback) {
            var
                $target = $(event.target),
                $label = $target.closest(selector.siblingLabel),
                inVisibleDOM = document.body.contains(event.target),
                notOnLabel = ($module.find($label).length === 0),
                notInMenu = ($target.closest($menu).length === 0)
            ;
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            if (inVisibleDOM && notOnLabel && notInMenu) {
              module.verbose('Triggering event', callback);
              callback();
              return true;
            }
            else {
              module.verbose(
                  'Event occurred in dropdown menu, canceling callback');
              return false;
            }
          }
        },

        action: {

          nothing: function () {
          },

          activate: function (text, value, element) {
            value = (value !== undefined)
                ? value
                : text
            ;
            if (module.can.activate($(element))) {
              module.set.selected(value, $(element));
              if (module.is.multiple() && !module.is.allFiltered()) {
                return;
              }
              else {
                module.hideAndClear();
              }
            }
          },

          select: function (text, value, element) {
            value = (value !== undefined)
                ? value
                : text
            ;
            if (module.can.activate($(element))) {
              module.set.value(value, $(element));
              if (module.is.multiple() && !module.is.allFiltered()) {
                return;
              }
              else {
                module.hideAndClear();
              }
            }
          },

          combo: function (text, value, element) {
            value = (value !== undefined)
                ? value
                : text
            ;
            module.set.selected(value, $(element));
            module.hideAndClear();
          },

          hide: function (text, value, element) {
            module.set.value(value, text);
            module.hideAndClear();
          }

        },

        get: {
          id: function () {
            return id;
          },
          defaultText: function () {
            return $module.data(metadata.defaultText);
          },
          defaultValue: function () {
            return $module.data(metadata.defaultValue);
          },
          placeholderText: function () {
            return $module.data(metadata.placeholderText) || '';
          },
          text: function () {
            return $text.text();
          },
          query: function () {
            return $.trim($search.val());
          },
          searchWidth: function (value) {
            value = (value !== undefined)
                ? value
                : $search.val()
            ;
            $sizer.text(value);
            // prevent rounding issues
            return Math.ceil($sizer.width() + 1);
          },
          selectionCount: function () {
            var
                values = module.get.values(),
                count
            ;
            count = ( module.is.multiple() )
                ? $.isArray(values)
                    ? values.length
                    : 0
                : (module.get.value() !== '')
                    ? 1
                    : 0
            ;
            return count;
          },
          transition: function ($subMenu) {
            return (settings.transition == 'auto')
                ? module.is.upward($subMenu)
                    ? 'slide up'
                    : 'slide down'
                : settings.transition
                ;
          },
          userValues: function () {
            var
                values = module.get.values()
            ;
            if (!values) {
              return false;
            }
            values = $.isArray(values)
                ? values
                : [values]
            ;
            return $.grep(values, function (value) {
              return (module.get.item(value) === false);
            });
          },
          uniqueArray: function (array) {
            return $.grep(array, function (value, index) {
              return $.inArray(value, array) === index;
            });
          },
          caretPosition: function () {
            var
                input = $search.get(0),
                range,
                rangeLength
            ;
            if ('selectionStart' in input) {
              return input.selectionStart;
            }
            else if (document.selection) {
              input.focus();
              range = document.selection.createRange();
              rangeLength = range.text.length;
              range.moveStart('character', -input.value.length);
              return range.text.length - rangeLength;
            }
          },
          value: function () {
            var
                value = ($input.length > 0)
                    ? $input.val()
                    : $module.data(metadata.value),
                isEmptyMultiselect = ($.isArray(value) && value.length === 1
                && value[0] === '')
            ;
            // prevents placeholder element from being selected when multiple
            return (value === undefined || isEmptyMultiselect)
                ? ''
                : value
                ;
          },
          values: function () {
            var
                value = module.get.value()
            ;
            if (value === '') {
              return '';
            }
            return ( !module.has.selectInput() && module.is.multiple() )
                ? (typeof value == 'string') // delimited string
                    ? value.split(settings.delimiter)
                    : ''
                : value
                ;
          },
          remoteValues: function () {
            var
                values = module.get.values(),
                remoteValues = false
            ;
            if (values) {
              if (typeof values == 'string') {
                values = [values];
              }
              $.each(values, function (index, value) {
                var
                    name = module.read.remoteData(value)
                ;
                module.verbose('Restoring value from session data', name,
                    value);
                if (name) {
                  if (!remoteValues) {
                    remoteValues = {};
                  }
                  remoteValues[value] = name;
                }
              });
            }
            return remoteValues;
          },
          choiceText: function ($choice, preserveHTML) {
            preserveHTML = (preserveHTML !== undefined)
                ? preserveHTML
                : settings.preserveHTML
            ;
            if ($choice) {
              if ($choice.find(selector.menu).length > 0) {
                module.verbose('Retrieving text of element with sub-menu');
                $choice = $choice.clone();
                $choice.find(selector.menu).remove();
                $choice.find(selector.menuIcon).remove();
              }
              return ($choice.data(metadata.text) !== undefined)
                  ? $choice.data(metadata.text)
                  : (preserveHTML)
                      ? $.trim($choice.html())
                      : $.trim($choice.text())
                  ;
            }
          },
          choiceValue: function ($choice, choiceText) {
            choiceText = choiceText || module.get.choiceText($choice);
            if (!$choice) {
              return false;
            }
            return ($choice.data(metadata.value) !== undefined)
                ? String($choice.data(metadata.value))
                : (typeof choiceText === 'string')
                    ? $.trim(choiceText.toLowerCase())
                    : String(choiceText)
                ;
          },
          inputEvent: function () {
            var
                input = $search[0]
            ;
            if (input) {
              return (input.oninput !== undefined)
                  ? 'input'
                  : (input.onpropertychange !== undefined)
                      ? 'propertychange'
                      : 'keyup'
                  ;
            }
            return false;
          },
          selectValues: function () {
            var
                select = {}
            ;
            select.values = [];
            $module
            .find('option')
            .each(function () {
              var
                  $option = $(this),
                  name = $option.html(),
                  disabled = $option.attr('disabled'),
                  value = ( $option.attr('value') !== undefined )
                      ? $option.attr('value')
                      : name
              ;
              if (settings.placeholder === 'auto' && value === '') {
                select.placeholder = name;
              }
              else {
                select.values.push({
                  name: name,
                  value: value,
                  disabled: disabled
                });
              }
            })
            ;
            if (settings.placeholder && settings.placeholder !== 'auto') {
              module.debug('Setting placeholder value to',
                  settings.placeholder);
              select.placeholder = settings.placeholder;
            }
            if (settings.sortSelect) {
              select.values.sort(function (a, b) {
                return (a.name > b.name)
                    ? 1
                    : -1
                    ;
              });
              module.debug('Retrieved and sorted values from select', select);
            }
            else {
              module.debug('Retrieved values from select', select);
            }
            return select;
          },
          activeItem: function () {
            return $item.filter('.' + className.active);
          },
          selectedItem: function () {
            var
                $selectedItem = $item.not(selector.unselectable).filter(
                    '.' + className.selected)
            ;
            return ($selectedItem.length > 0)
                ? $selectedItem
                : $item.eq(0)
                ;
          },
          itemWithAdditions: function (value) {
            var
                $items = module.get.item(value),
                $userItems = module.create.userChoice(value),
                hasUserItems = ($userItems && $userItems.length > 0)
            ;
            if (hasUserItems) {
              $items = ($items.length > 0)
                  ? $items.add($userItems)
                  : $userItems
              ;
            }
            return $items;
          },
          item: function (value, strict) {
            var
                $selectedItem = false,
                shouldSearch,
                isMultiple
            ;
            value = (value !== undefined)
                ? value
                : ( module.get.values() !== undefined)
                    ? module.get.values()
                    : module.get.text()
            ;
            shouldSearch = (isMultiple)
                ? (value.length > 0)
                : (value !== undefined && value !== null)
            ;
            isMultiple = (module.is.multiple() && $.isArray(value));
            strict = (value === '' || value === 0)
                ? true
                : strict || false
            ;
            if (shouldSearch) {
              $item
              .each(function () {
                var
                    $choice = $(this),
                    optionText = module.get.choiceText($choice),
                    optionValue = module.get.choiceValue($choice, optionText)
                ;
                // safe early exit
                if (optionValue === null || optionValue === undefined) {
                  return;
                }
                if (isMultiple) {
                  if ($.inArray(String(optionValue), value) !== -1 || $.inArray(
                          optionText, value) !== -1) {
                    $selectedItem = ($selectedItem)
                        ? $selectedItem.add($choice)
                        : $choice
                    ;
                  }
                }
                else if (strict) {
                  module.verbose(
                      'Ambiguous dropdown value using strict type check',
                      $choice, value);
                  if (optionValue === value || optionText === value) {
                    $selectedItem = $choice;
                    return true;
                  }
                }
                else {
                  if (String(optionValue) == String(value) || optionText
                      == value) {
                    module.verbose('Found select item by value', optionValue,
                        value);
                    $selectedItem = $choice;
                    return true;
                  }
                }
              })
              ;
            }
            return $selectedItem;
          }
        },

        check: {
          maxSelections: function (selectionCount) {
            if (settings.maxSelections) {
              selectionCount = (selectionCount !== undefined)
                  ? selectionCount
                  : module.get.selectionCount()
              ;
              if (selectionCount >= settings.maxSelections) {
                module.debug('Maximum selection count reached');
                if (settings.useLabels) {
                  $item.addClass(className.filtered);
                  module.add.message(message.maxSelections);
                }
                return true;
              }
              else {
                module.verbose('No longer at maximum selection count');
                module.remove.message();
                module.remove.filteredItem();
                if (module.is.searchSelection()) {
                  module.filterItems();
                }
                return false;
              }
            }
            return true;
          }
        },

        restore: {
          defaults: function () {
            module.clear();
            module.restore.defaultText();
            module.restore.defaultValue();
          },
          defaultText: function () {
            var
                defaultText = module.get.defaultText(),
                placeholderText = module.get.placeholderText
            ;
            if (defaultText === placeholderText) {
              module.debug('Restoring default placeholder text', defaultText);
              module.set.placeholderText(defaultText);
            }
            else {
              module.debug('Restoring default text', defaultText);
              module.set.text(defaultText);
            }
          },
          placeholderText: function () {
            module.set.placeholderText();
          },
          defaultValue: function () {
            var
                defaultValue = module.get.defaultValue()
            ;
            if (defaultValue !== undefined) {
              module.debug('Restoring default value', defaultValue);
              if (defaultValue !== '') {
                module.set.value(defaultValue);
                module.set.selected();
              }
              else {
                module.remove.activeItem();
                module.remove.selectedItem();
              }
            }
          },
          labels: function () {
            if (settings.allowAdditions) {
              if (!settings.useLabels) {
                module.error(error.labels);
                settings.useLabels = true;
              }
              module.debug('Restoring selected values');
              module.create.userLabels();
            }
            module.check.maxSelections();
          },
          selected: function () {
            module.restore.values();
            if (module.is.multiple()) {
              module.debug('Restoring previously selected values and labels');
              module.restore.labels();
            }
            else {
              module.debug('Restoring previously selected values');
            }
          },
          values: function () {
            // prevents callbacks from occurring on initial load
            module.set.initialLoad();
            if (settings.apiSettings && settings.saveRemoteData
                && module.get.remoteValues()) {
              module.restore.remoteValues();
            }
            else {
              module.set.selected();
            }
            module.remove.initialLoad();
          },
          remoteValues: function () {
            var
                values = module.get.remoteValues()
            ;
            module.debug('Recreating selected from session data', values);
            if (values) {
              if (module.is.single()) {
                $.each(values, function (value, name) {
                  module.set.text(name);
                });
              }
              else {
                $.each(values, function (value, name) {
                  module.add.label(value, name);
                });
              }
            }
          }
        },

        read: {
          remoteData: function (value) {
            var
                name
            ;
            if (window.Storage === undefined) {
              module.error(error.noStorage);
              return;
            }
            name = sessionStorage.getItem(value);
            return (name !== undefined)
                ? name
                : false
                ;
          }
        },

        save: {
          defaults: function () {
            module.save.defaultText();
            module.save.placeholderText();
            module.save.defaultValue();
          },
          defaultValue: function () {
            var
                value = module.get.value()
            ;
            module.verbose('Saving default value as', value);
            $module.data(metadata.defaultValue, value);
          },
          defaultText: function () {
            var
                text = module.get.text()
            ;
            module.verbose('Saving default text as', text);
            $module.data(metadata.defaultText, text);
          },
          placeholderText: function () {
            var
                text
            ;
            if (settings.placeholder !== false && $text.hasClass(
                    className.placeholder)) {
              text = module.get.text();
              module.verbose('Saving placeholder text as', text);
              $module.data(metadata.placeholderText, text);
            }
          },
          remoteData: function (name, value) {
            if (window.Storage === undefined) {
              module.error(error.noStorage);
              return;
            }
            module.verbose('Saving remote data to session storage', value,
                name);
            sessionStorage.setItem(value, name);
          }
        },

        clear: function () {
          if (module.is.multiple() && settings.useLabels) {
            module.remove.labels();
          }
          else {
            module.remove.activeItem();
            module.remove.selectedItem();
          }
          module.set.placeholderText();
          module.clearValue();
        },

        clearValue: function () {
          module.set.value('');
        },

        scrollPage: function (direction, $selectedItem) {
          var
              $currentItem = $selectedItem || module.get.selectedItem(),
              $menu = $currentItem.closest(selector.menu),
              menuHeight = $menu.outerHeight(),
              currentScroll = $menu.scrollTop(),
              itemHeight = $item.eq(0).outerHeight(),
              itemsPerPage = Math.floor(menuHeight / itemHeight),
              maxScroll = $menu.prop('scrollHeight'),
              newScroll = (direction == 'up')
                  ? currentScroll - (itemHeight * itemsPerPage)
                  : currentScroll + (itemHeight * itemsPerPage),
              $selectableItem = $item.not(selector.unselectable),
              isWithinRange,
              $nextSelectedItem,
              elementIndex
          ;
          elementIndex = (direction == 'up')
              ? $selectableItem.index($currentItem) - itemsPerPage
              : $selectableItem.index($currentItem) + itemsPerPage
          ;
          isWithinRange = (direction == 'up')
              ? (elementIndex >= 0)
              : (elementIndex < $selectableItem.length)
          ;
          $nextSelectedItem = (isWithinRange)
              ? $selectableItem.eq(elementIndex)
              : (direction == 'up')
                  ? $selectableItem.first()
                  : $selectableItem.last()
          ;
          if ($nextSelectedItem.length > 0) {
            module.debug('Scrolling page', direction, $nextSelectedItem);
            $currentItem
            .removeClass(className.selected)
            ;
            $nextSelectedItem
            .addClass(className.selected)
            ;
            if (settings.selectOnKeydown && module.is.single()) {
              module.set.selectedItem($nextSelectedItem);
            }
            $menu
            .scrollTop(newScroll)
            ;
          }
        },

        set: {
          filtered: function () {
            var
                isMultiple = module.is.multiple(),
                isSearch = module.is.searchSelection(),
                isSearchMultiple = (isMultiple && isSearch),
                searchValue = (isSearch)
                    ? module.get.query()
                    : '',
                hasSearchValue = (typeof searchValue === 'string'
                && searchValue.length > 0),
                searchWidth = module.get.searchWidth(),
                valueIsSet = searchValue !== ''
            ;
            if (isMultiple && hasSearchValue) {
              module.verbose('Adjusting input width', searchWidth,
                  settings.glyphWidth);
              $search.css('width', searchWidth);
            }
            if (hasSearchValue || (isSearchMultiple && valueIsSet)) {
              module.verbose('Hiding placeholder text');
              $text.addClass(className.filtered);
            }
            else if (!isMultiple || (isSearchMultiple && !valueIsSet)) {
              module.verbose('Showing placeholder text');
              $text.removeClass(className.filtered);
            }
          },
          empty: function () {
            $module.addClass(className.empty);
          },
          loading: function () {
            $module.addClass(className.loading);
          },
          placeholderText: function (text) {
            text = text || module.get.placeholderText();
            module.debug('Setting placeholder text', text);
            module.set.text(text);
            $text.addClass(className.placeholder);
          },
          tabbable: function () {
            if (module.is.searchSelection()) {
              module.debug('Added tabindex to searchable dropdown');
              $search
              .val('')
              .attr('tabindex', 0)
              ;
              $menu
              .attr('tabindex', -1)
              ;
            }
            else {
              module.debug('Added tabindex to dropdown');
              if ($module.attr('tabindex') === undefined) {
                $module
                .attr('tabindex', 0)
                ;
                $menu
                .attr('tabindex', -1)
                ;
              }
            }
          },
          initialLoad: function () {
            module.verbose('Setting initial load');
            initialLoad = true;
          },
          activeItem: function ($item) {
            if (settings.allowAdditions && $item.filter(
                    selector.addition).length > 0) {
              $item.addClass(className.filtered);
            }
            else {
              $item.addClass(className.active);
            }
          },
          partialSearch: function (text) {
            var
                length = module.get.query().length
            ;
            $search.val(text.substr(0, length));
          },
          scrollPosition: function ($item, forceScroll) {
            var
                edgeTolerance = 5,
                $menu,
                hasActive,
                offset,
                itemHeight,
                itemOffset,
                menuOffset,
                menuScroll,
                menuHeight,
                abovePage,
                belowPage
            ;

            $item = $item || module.get.selectedItem();
            $menu = $item.closest(selector.menu);
            hasActive = ($item && $item.length > 0);
            forceScroll = (forceScroll !== undefined)
                ? forceScroll
                : false
            ;
            if ($item && $menu.length > 0 && hasActive) {
              itemOffset = $item.position().top;

              $menu.addClass(className.loading);
              menuScroll = $menu.scrollTop();
              menuOffset = $menu.offset().top;
              itemOffset = $item.offset().top;
              offset = menuScroll - menuOffset + itemOffset;
              if (!forceScroll) {
                menuHeight = $menu.height();
                belowPage = menuScroll + menuHeight < (offset + edgeTolerance);
                abovePage = ((offset - edgeTolerance) < menuScroll);
              }
              module.debug('Scrolling to active item', offset);
              if (forceScroll || abovePage || belowPage) {
                $menu.scrollTop(offset);
              }
              $menu.removeClass(className.loading);
            }
          },
          text: function (text) {
            if (settings.action !== 'select') {
              if (settings.action == 'combo') {
                module.debug('Changing combo button text', text, $combo);
                if (settings.preserveHTML) {
                  $combo.html(text);
                }
                else {
                  $combo.text(text);
                }
              }
              else {
                if (text !== module.get.placeholderText()) {
                  $text.removeClass(className.placeholder);
                }
                module.debug('Changing text', text, $text);
                $text
                .removeClass(className.filtered)
                ;
                if (settings.preserveHTML) {
                  $text.html(text);
                }
                else {
                  $text.text(text);
                }
              }
            }
          },
          selectedItem: function ($item) {
            var
                value = module.get.choiceValue($item),
                searchText = module.get.choiceText($item, false),
                text = module.get.choiceText($item, true)
            ;
            module.debug('Setting user selection to item', $item);
            module.remove.activeItem();
            module.set.partialSearch(searchText);
            module.set.activeItem($item);
            module.set.selected(value, $item);
            module.set.text(text);
          },
          selectedLetter: function (letter) {
            var
                $selectedItem = $item.filter('.' + className.selected),
                alreadySelectedLetter = $selectedItem.length > 0
                    && module.has.firstLetter($selectedItem, letter),
                $nextValue = false,
                $nextItem
            ;
            // check next of same letter
            if (alreadySelectedLetter) {
              $nextItem = $selectedItem.nextAll($item).eq(0);
              if (module.has.firstLetter($nextItem, letter)) {
                $nextValue = $nextItem;
              }
            }
            // check all values
            if (!$nextValue) {
              $item
              .each(function () {
                if (module.has.firstLetter($(this), letter)) {
                  $nextValue = $(this);
                  return false;
                }
              })
              ;
            }
            // set next value
            if ($nextValue) {
              module.verbose('Scrolling to next value with letter', letter);
              module.set.scrollPosition($nextValue);
              $selectedItem.removeClass(className.selected);
              $nextValue.addClass(className.selected);
              if (settings.selectOnKeydown && module.is.single()) {
                module.set.selectedItem($nextValue);
              }
            }
          },
          direction: function ($menu) {
            if (settings.direction == 'auto') {
              if (module.is.onScreen($menu)) {
                module.remove.upward($menu);
              }
              else {
                module.set.upward($menu);
              }
            }
            else if (settings.direction == 'upward') {
              module.set.upward($menu);
            }
          },
          upward: function ($menu) {
            var $element = $menu || $module;
            $element.addClass(className.upward);
          },
          value: function (value, text, $selected) {
            var
                escapedValue = module.escape.value(value),
                hasInput = ($input.length > 0),
                isAddition = !module.has.value(value),
                currentValue = module.get.values(),
                stringValue = (value !== undefined)
                    ? String(value)
                    : value,
                newValue
            ;
            if (hasInput) {
              if (!settings.allowReselection && stringValue == currentValue) {
                module.verbose('Skipping value update already same value',
                    value, currentValue);
                if (!module.is.initialLoad()) {
                  return;
                }
              }

              if (module.is.single() && module.has.selectInput()
                  && module.can.extendSelect()) {
                module.debug('Adding user option', value);
                module.add.optionValue(value);
              }
              module.debug('Updating input value', escapedValue, currentValue);
              internalChange = true;
              $input
              .val(escapedValue)
              ;
              if (settings.fireOnInit === false && module.is.initialLoad()) {
                module.debug(
                    'Input native change event ignored on initial load');
              }
              else {
                module.trigger.change();
              }
              internalChange = false;
            }
            else {
              module.verbose('Storing value in metadata', escapedValue, $input);
              if (escapedValue !== currentValue) {
                $module.data(metadata.value, stringValue);
              }
            }
            if (settings.fireOnInit === false && module.is.initialLoad()) {
              module.verbose('No callback on initial load', settings.onChange);
            }
            else {
              settings.onChange.call(element, value, text, $selected);
            }
          },
          active: function () {
            $module
            .addClass(className.active)
            ;
          },
          multiple: function () {
            $module.addClass(className.multiple);
          },
          visible: function () {
            $module.addClass(className.visible);
          },
          exactly: function (value, $selectedItem) {
            module.debug('Setting selected to exact values');
            module.clear();
            module.set.selected(value, $selectedItem);
          },
          selected: function (value, $selectedItem) {
            var
                isMultiple = module.is.multiple(),
                $userSelectedItem
            ;
            $selectedItem = (settings.allowAdditions)
                ? $selectedItem || module.get.itemWithAdditions(value)
                : $selectedItem || module.get.item(value)
            ;
            if (!$selectedItem) {
              return;
            }
            module.debug('Setting selected menu item to', $selectedItem);
            if (module.is.multiple()) {
              module.remove.searchWidth();
            }
            if (module.is.single()) {
              module.remove.activeItem();
              module.remove.selectedItem();
            }
            else if (settings.useLabels) {
              module.remove.selectedItem();
            }
            // select each item
            $selectedItem
            .each(function () {
              var
                  $selected = $(this),
                  selectedText = module.get.choiceText($selected),
                  selectedValue = module.get.choiceValue($selected,
                      selectedText),

                  isFiltered = $selected.hasClass(className.filtered),
                  isActive = $selected.hasClass(className.active),
                  isUserValue = $selected.hasClass(className.addition),
                  shouldAnimate = (isMultiple && $selectedItem.length == 1)
              ;
              if (isMultiple) {
                if (!isActive || isUserValue) {
                  if (settings.apiSettings && settings.saveRemoteData) {
                    module.save.remoteData(selectedText, selectedValue);
                  }
                  if (settings.useLabels) {
                    module.add.value(selectedValue, selectedText, $selected);
                    module.add.label(selectedValue, selectedText,
                        shouldAnimate);
                    module.set.activeItem($selected);
                    module.filterActive();
                    module.select.nextAvailable($selectedItem);
                  }
                  else {
                    module.add.value(selectedValue, selectedText, $selected);
                    module.set.text(module.add.variables(message.count));
                    module.set.activeItem($selected);
                  }
                }
                else if (!isFiltered) {
                  module.debug('Selected active value, removing label');
                  module.remove.selected(selectedValue);
                }
              }
              else {
                if (settings.apiSettings && settings.saveRemoteData) {
                  module.save.remoteData(selectedText, selectedValue);
                }
                module.set.text(selectedText);
                module.set.value(selectedValue, selectedText, $selected);
                $selected
                .addClass(className.active)
                .addClass(className.selected)
                ;
              }
            })
            ;
          }
        },

        add: {
          label: function (value, text, shouldAnimate) {
            var
                $next = module.is.searchSelection()
                    ? $search
                    : $text,
                escapedValue = module.escape.value(value),
                $label
            ;
            $label = $('<a />')
            .addClass(className.label)
            .attr('data-' + metadata.value, escapedValue)
            .html(templates.label(escapedValue, text))
            ;
            $label = settings.onLabelCreate.call($label, escapedValue, text);

            if (module.has.label(value)) {
              module.debug('Label already exists, skipping', escapedValue);
              return;
            }
            if (settings.label.variation) {
              $label.addClass(settings.label.variation);
            }
            if (shouldAnimate === true) {
              module.debug('Animating in label', $label);
              $label
              .addClass(className.hidden)
              .insertBefore($next)
              .transition(settings.label.transition, settings.label.duration)
              ;
            }
            else {
              module.debug('Adding selection label', $label);
              $label
              .insertBefore($next)
              ;
            }
          },
          message: function (message) {
            var
                $message = $menu.children(selector.message),
                html = settings.templates.message(module.add.variables(message))
            ;
            if ($message.length > 0) {
              $message
              .html(html)
              ;
            }
            else {
              $message = $('<div/>')
              .html(html)
              .addClass(className.message)
              .appendTo($menu)
              ;
            }
          },
          optionValue: function (value) {
            var
                escapedValue = module.escape.value(value),
                $option = $input.find(
                    'option[value="' + module.escape.string(escapedValue)
                    + '"]'),
                hasOption = ($option.length > 0)
            ;
            if (hasOption) {
              return;
            }
            // temporarily disconnect observer
            module.disconnect.selectObserver();
            if (module.is.single()) {
              module.verbose('Removing previous user addition');
              $input.find('option.' + className.addition).remove();
            }
            $('<option/>')
            .prop('value', escapedValue)
            .addClass(className.addition)
            .html(value)
            .appendTo($input)
            ;
            module.verbose('Adding user addition as an <option>', value);
            module.observe.select();
          },
          userSuggestion: function (value) {
            var
                $addition = $menu.children(selector.addition),
                $existingItem = module.get.item(value),
                alreadyHasValue = $existingItem && $existingItem.not(
                        selector.addition).length,
                hasUserSuggestion = $addition.length > 0,
                html
            ;
            if (settings.useLabels && module.has.maxSelections()) {
              return;
            }
            if (value === '' || alreadyHasValue) {
              $addition.remove();
              return;
            }
            if (hasUserSuggestion) {
              $addition
              .data(metadata.value, value)
              .data(metadata.text, value)
              .attr('data-' + metadata.value, value)
              .attr('data-' + metadata.text, value)
              .removeClass(className.filtered)
              ;
              if (!settings.hideAdditions) {
                html = settings.templates.addition(
                    module.add.variables(message.addResult, value));
                $addition
                .html(html)
                ;
              }
              module.verbose('Replacing user suggestion with new value',
                  $addition);
            }
            else {
              $addition = module.create.userChoice(value);
              $addition
              .prependTo($menu)
              ;
              module.verbose(
                  'Adding item choice to menu corresponding with user choice addition',
                  $addition);
            }
            if (!settings.hideAdditions || module.is.allFiltered()) {
              $addition
              .addClass(className.selected)
              .siblings()
              .removeClass(className.selected)
              ;
            }
            module.refreshItems();
          },
          variables: function (message, term) {
            var
                hasCount = (message.search('{count}') !== -1),
                hasMaxCount = (message.search('{maxCount}') !== -1),
                hasTerm = (message.search('{term}') !== -1),
                values,
                count,
                query
            ;
            module.verbose('Adding templated variables to message', message);
            if (hasCount) {
              count = module.get.selectionCount();
              message = message.replace('{count}', count);
            }
            if (hasMaxCount) {
              count = module.get.selectionCount();
              message = message.replace('{maxCount}', settings.maxSelections);
            }
            if (hasTerm) {
              query = term || module.get.query();
              message = message.replace('{term}', query);
            }
            return message;
          },
          value: function (addedValue, addedText, $selectedItem) {
            var
                currentValue = module.get.values(),
                newValue
            ;
            if (addedValue === '') {
              module.debug('Cannot select blank values from multiselect');
              return;
            }
            // extend current array
            if ($.isArray(currentValue)) {
              newValue = currentValue.concat([addedValue]);
              newValue = module.get.uniqueArray(newValue);
            }
            else {
              newValue = [addedValue];
            }
            // add values
            if (module.has.selectInput()) {
              if (module.can.extendSelect()) {
                module.debug('Adding value to select', addedValue, newValue,
                    $input);
                module.add.optionValue(addedValue);
              }
            }
            else {
              newValue = newValue.join(settings.delimiter);
              module.debug('Setting hidden input to delimited value', newValue,
                  $input);
            }

            if (settings.fireOnInit === false && module.is.initialLoad()) {
              module.verbose('Skipping onadd callback on initial load',
                  settings.onAdd);
            }
            else {
              settings.onAdd.call(element, addedValue, addedText,
                  $selectedItem);
            }
            module.set.value(newValue, addedValue, addedText, $selectedItem);
            module.check.maxSelections();
          }
        },

        remove: {
          active: function () {
            $module.removeClass(className.active);
          },
          activeLabel: function () {
            $module.find(selector.label).removeClass(className.active);
          },
          empty: function () {
            $module.removeClass(className.empty);
          },
          loading: function () {
            $module.removeClass(className.loading);
          },
          initialLoad: function () {
            initialLoad = false;
          },
          upward: function ($menu) {
            var $element = $menu || $module;
            $element.removeClass(className.upward);
          },
          visible: function () {
            $module.removeClass(className.visible);
          },
          activeItem: function () {
            $item.removeClass(className.active);
          },
          filteredItem: function () {
            if (settings.useLabels && module.has.maxSelections()) {
              return;
            }
            if (settings.useLabels && module.is.multiple()) {
              $item.not('.' + className.active).removeClass(className.filtered);
            }
            else {
              $item.removeClass(className.filtered);
            }
            module.remove.empty();
          },
          optionValue: function (value) {
            var
                escapedValue = module.escape.value(value),
                $option = $input.find(
                    'option[value="' + module.escape.string(escapedValue)
                    + '"]'),
                hasOption = ($option.length > 0)
            ;
            if (!hasOption || !$option.hasClass(className.addition)) {
              return;
            }
            // temporarily disconnect observer
            if (selectObserver) {
              selectObserver.disconnect();
              module.verbose('Temporarily disconnecting mutation observer');
            }
            $option.remove();
            module.verbose('Removing user addition as an <option>',
                escapedValue);
            if (selectObserver) {
              selectObserver.observe($input[0], {
                childList: true,
                subtree: true
              });
            }
          },
          message: function () {
            $menu.children(selector.message).remove();
          },
          searchWidth: function () {
            $search.css('width', '');
          },
          searchTerm: function () {
            module.verbose('Cleared search term');
            $search.val('');
            module.set.filtered();
          },
          userAddition: function () {
            $item.filter(selector.addition).remove();
          },
          selected: function (value, $selectedItem) {
            $selectedItem = (settings.allowAdditions)
                ? $selectedItem || module.get.itemWithAdditions(value)
                : $selectedItem || module.get.item(value)
            ;

            if (!$selectedItem) {
              return false;
            }

            $selectedItem
            .each(function () {
              var
                  $selected = $(this),
                  selectedText = module.get.choiceText($selected),
                  selectedValue = module.get.choiceValue($selected,
                      selectedText)
              ;
              if (module.is.multiple()) {
                if (settings.useLabels) {
                  module.remove.value(selectedValue, selectedText, $selected);
                  module.remove.label(selectedValue);
                }
                else {
                  module.remove.value(selectedValue, selectedText, $selected);
                  if (module.get.selectionCount() === 0) {
                    module.set.placeholderText();
                  }
                  else {
                    module.set.text(module.add.variables(message.count));
                  }
                }
              }
              else {
                module.remove.value(selectedValue, selectedText, $selected);
              }
              $selected
              .removeClass(className.filtered)
              .removeClass(className.active)
              ;
              if (settings.useLabels) {
                $selected.removeClass(className.selected);
              }
            })
            ;
          },
          selectedItem: function () {
            $item.removeClass(className.selected);
          },
          value: function (removedValue, removedText, $removedItem) {
            var
                values = module.get.values(),
                newValue
            ;
            if (module.has.selectInput()) {
              module.verbose('Input is <select> removing selected option',
                  removedValue);
              newValue = module.remove.arrayValue(removedValue, values);
              module.remove.optionValue(removedValue);
            }
            else {
              module.verbose('Removing from delimited values', removedValue);
              newValue = module.remove.arrayValue(removedValue, values);
              newValue = newValue.join(settings.delimiter);
            }
            if (settings.fireOnInit === false && module.is.initialLoad()) {
              module.verbose('No callback on initial load', settings.onRemove);
            }
            else {
              settings.onRemove.call(element, removedValue, removedText,
                  $removedItem);
            }
            module.set.value(newValue, removedText, $removedItem);
            module.check.maxSelections();
          },
          arrayValue: function (removedValue, values) {
            if (!$.isArray(values)) {
              values = [values];
            }
            values = $.grep(values, function (value) {
              return (removedValue != value);
            });
            module.verbose('Removed value from delimited string', removedValue,
                values);
            return values;
          },
          label: function (value, shouldAnimate) {
            var
                $labels = $module.find(selector.label),
                $removedLabel = $labels.filter(
                    '[data-' + metadata.value + '="' + module.escape.string(
                        value) + '"]')
            ;
            module.verbose('Removing label', $removedLabel);
            $removedLabel.remove();
          },
          activeLabels: function ($activeLabels) {
            $activeLabels = $activeLabels || $module.find(
                    selector.label).filter('.' + className.active);
            module.verbose('Removing active label selections', $activeLabels);
            module.remove.labels($activeLabels);
          },
          labels: function ($labels) {
            $labels = $labels || $module.find(selector.label);
            module.verbose('Removing labels', $labels);
            $labels
            .each(function () {
              var
                  $label = $(this),
                  value = $label.data(metadata.value),
                  stringValue = (value !== undefined)
                      ? String(value)
                      : value,
                  isUserValue = module.is.userValue(stringValue)
              ;
              if (settings.onLabelRemove.call($label, value) === false) {
                module.debug('Label remove callback cancelled removal');
                return;
              }
              module.remove.message();
              if (isUserValue) {
                module.remove.value(stringValue);
                module.remove.label(stringValue);
              }
              else {
                // selected will also remove label
                module.remove.selected(stringValue);
              }
            })
            ;
          },
          tabbable: function () {
            if (module.is.searchSelection()) {
              module.debug('Searchable dropdown initialized');
              $search
              .removeAttr('tabindex')
              ;
              $menu
              .removeAttr('tabindex')
              ;
            }
            else {
              module.debug('Simple selection dropdown initialized');
              $module
              .removeAttr('tabindex')
              ;
              $menu
              .removeAttr('tabindex')
              ;
            }
          }
        },

        has: {
          menuSearch: function () {
            return (module.has.search() && $search.closest($menu).length > 0);
          },
          search: function () {
            return ($search.length > 0);
          },
          sizer: function () {
            return ($sizer.length > 0);
          },
          selectInput: function () {
            return ( $input.is('select') );
          },
          minCharacters: function (searchTerm) {
            if (settings.minCharacters) {
              searchTerm = (searchTerm !== undefined)
                  ? String(searchTerm)
                  : String(module.get.query())
              ;
              return (searchTerm.length >= settings.minCharacters);
            }
            return true;
          },
          firstLetter: function ($item, letter) {
            var
                text,
                firstLetter
            ;
            if (!$item || $item.length === 0 || typeof letter !== 'string') {
              return false;
            }
            text = module.get.choiceText($item, false);
            letter = letter.toLowerCase();
            firstLetter = String(text).charAt(0).toLowerCase();
            return (letter == firstLetter);
          },
          input: function () {
            return ($input.length > 0);
          },
          items: function () {
            return ($item.length > 0);
          },
          menu: function () {
            return ($menu.length > 0);
          },
          message: function () {
            return ($menu.children(selector.message).length !== 0);
          },
          label: function (value) {
            var
                escapedValue = module.escape.value(value),
                $labels = $module.find(selector.label)
            ;
            return ($labels.filter(
                '[data-' + metadata.value + '="' + module.escape.string(
                    escapedValue) + '"]').length > 0);
          },
          maxSelections: function () {
            return (settings.maxSelections && module.get.selectionCount()
            >= settings.maxSelections);
          },
          allResultsFiltered: function () {
            var
                $normalResults = $item.not(selector.addition)
            ;
            return ($normalResults.filter(selector.unselectable).length
            === $normalResults.length);
          },
          userSuggestion: function () {
            return ($menu.children(selector.addition).length > 0);
          },
          query: function () {
            return (module.get.query() !== '');
          },
          value: function (value) {
            var
                values = module.get.values(),
                hasValue = $.isArray(values)
                    ? values && ($.inArray(value, values) !== -1)
                    : (values == value)
            ;
            return (hasValue)
                ? true
                : false
                ;
          }
        },

        is: {
          active: function () {
            return $module.hasClass(className.active);
          },
          bubbledLabelClick: function (event) {
            return $(event.target).is('select, input') && $module.closest(
                    'label').length > 0;
          },
          bubbledIconClick: function (event) {
            return $(event.target).closest($icon).length > 0;
          },
          alreadySetup: function () {
            return ($module.is('select') && $module.parent(
                selector.dropdown).length > 0 && $module.prev().length === 0);
          },
          animating: function ($subMenu) {
            return ($subMenu)
                ? $subMenu.transition && $subMenu.transition('is animating')
                : $menu.transition && $menu.transition('is animating')
                ;
          },
          disabled: function () {
            return $module.hasClass(className.disabled);
          },
          focused: function () {
            return (document.activeElement === $module[0]);
          },
          focusedOnSearch: function () {
            return (document.activeElement === $search[0]);
          },
          allFiltered: function () {
            return ( (module.is.multiple() || module.has.search())
            && !(settings.hideAdditions == false && module.has.userSuggestion())
            && !module.has.message() && module.has.allResultsFiltered() );
          },
          hidden: function ($subMenu) {
            return !module.is.visible($subMenu);
          },
          initialLoad: function () {
            return initialLoad;
          },
          onScreen: function ($subMenu) {
            var
                $currentMenu = $subMenu || $menu,
                canOpenDownward = true,
                onScreen = {},
                calculations
            ;
            $currentMenu.addClass(className.loading);
            calculations = {
              context: {
                scrollTop: $context.scrollTop(),
                height: $context.outerHeight()
              },
              menu: {
                offset: $currentMenu.offset(),
                height: $currentMenu.outerHeight()
              }
            };
            if (module.is.verticallyScrollableContext()) {
              calculations.menu.offset.top += calculations.context.scrollTop;
            }
            onScreen = {
              above: (calculations.context.scrollTop)
              <= calculations.menu.offset.top - calculations.menu.height,
              below: (calculations.context.scrollTop
              + calculations.context.height) >= calculations.menu.offset.top
              + calculations.menu.height
            };
            if (onScreen.below) {
              module.verbose('Dropdown can fit in context downward', onScreen);
              canOpenDownward = true;
            }
            else if (!onScreen.below && !onScreen.above) {
              module.verbose(
                  'Dropdown cannot fit in either direction, favoring downward',
                  onScreen);
              canOpenDownward = true;
            }
            else {
              module.verbose('Dropdown cannot fit below, opening upward',
                  onScreen);
              canOpenDownward = false;
            }
            $currentMenu.removeClass(className.loading);
            return canOpenDownward;
          },
          inObject: function (needle, object) {
            var
                found = false
            ;
            $.each(object, function (index, property) {
              if (property == needle) {
                found = true;
                return true;
              }
            });
            return found;
          },
          multiple: function () {
            return $module.hasClass(className.multiple);
          },
          remote: function () {
            return settings.apiSettings && module.can.useAPI();
          },
          single: function () {
            return !module.is.multiple();
          },
          selectMutation: function (mutations) {
            var
                selectChanged = false
            ;
            $.each(mutations, function (index, mutation) {
              if (mutation.target && $(mutation.target).is('select')) {
                selectChanged = true;
                return true;
              }
            });
            return selectChanged;
          },
          search: function () {
            return $module.hasClass(className.search);
          },
          searchSelection: function () {
            return ( module.has.search() && $search.parent(
                selector.dropdown).length === 1 );
          },
          selection: function () {
            return $module.hasClass(className.selection);
          },
          userValue: function (value) {
            return ($.inArray(value, module.get.userValues()) !== -1);
          },
          upward: function ($menu) {
            var $element = $menu || $module;
            return $element.hasClass(className.upward);
          },
          visible: function ($subMenu) {
            return ($subMenu)
                ? $subMenu.hasClass(className.visible)
                : $menu.hasClass(className.visible)
                ;
          },
          verticallyScrollableContext: function () {
            var
                overflowY = ($context.get(0) !== window)
                    ? $context.css('overflow-y')
                    : false
            ;
            return (overflowY == 'auto' || overflowY == 'scroll');
          }
        },

        can: {
          activate: function ($item) {
            if (settings.useLabels) {
              return true;
            }
            if (!module.has.maxSelections()) {
              return true;
            }
            if (module.has.maxSelections() && $item.hasClass(
                    className.active)) {
              return true;
            }
            return false;
          },
          click: function () {
            return (hasTouch || settings.on == 'click');
          },
          extendSelect: function () {
            return settings.allowAdditions || settings.apiSettings;
          },
          show: function () {
            return !module.is.disabled() && (module.has.items()
                || module.has.message());
          },
          useAPI: function () {
            return $.fn.api !== undefined;
          }
        },

        animate: {
          show: function (callback, $subMenu) {
            var
                $currentMenu = $subMenu || $menu,
                start = ($subMenu)
                    ? function () {
                    }
                    : function () {
                      module.hideSubMenus();
                      module.hideOthers();
                      module.set.active();
                    },
                transition
            ;
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            module.verbose('Doing menu show animation', $currentMenu);
            module.set.direction($subMenu);
            transition = module.get.transition($subMenu);
            if (module.is.selection()) {
              module.set.scrollPosition(module.get.selectedItem(), true);
            }
            if (module.is.hidden($currentMenu) || module.is.animating(
                    $currentMenu)) {
              if (transition == 'none') {
                start();
                $currentMenu.transition('show');
                callback.call(element);
              }
              else if ($.fn.transition !== undefined && $module.transition(
                      'is supported')) {
                $currentMenu
                .transition({
                  animation: transition + ' in',
                  debug: settings.debug,
                  verbose: settings.verbose,
                  duration: settings.duration,
                  queue: true,
                  onStart: start,
                  onComplete: function () {
                    callback.call(element);
                  }
                })
                ;
              }
              else {
                module.error(error.noTransition, transition);
              }
            }
          },
          hide: function (callback, $subMenu) {
            var
                $currentMenu = $subMenu || $menu,
                duration = ($subMenu)
                    ? (settings.duration * 0.9)
                    : settings.duration,
                start = ($subMenu)
                    ? function () {
                    }
                    : function () {
                      if (module.can.click()) {
                        module.unbind.intent();
                      }
                      module.remove.active();
                    },
                transition = module.get.transition($subMenu)
            ;
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            if (module.is.visible($currentMenu) || module.is.animating(
                    $currentMenu)) {
              module.verbose('Doing menu hide animation', $currentMenu);

              if (transition == 'none') {
                start();
                $currentMenu.transition('hide');
                callback.call(element);
              }
              else if ($.fn.transition !== undefined && $module.transition(
                      'is supported')) {
                $currentMenu
                .transition({
                  animation: transition + ' out',
                  duration: settings.duration,
                  debug: settings.debug,
                  verbose: settings.verbose,
                  queue: true,
                  onStart: start,
                  onComplete: function () {
                    if (settings.direction == 'auto') {
                      module.remove.upward($subMenu);
                    }
                    callback.call(element);
                  }
                })
                ;
              }
              else {
                module.error(error.transition);
              }
            }
          }
        },

        hideAndClear: function () {
          module.remove.searchTerm();
          if (module.has.maxSelections()) {
            return;
          }
          if (module.has.search()) {
            module.hide(function () {
              module.remove.filteredItem();
            });
          }
          else {
            module.hide();
          }
        },

        delay: {
          show: function () {
            module.verbose('Delaying show event to ensure user intent');
            clearTimeout(module.timer);
            module.timer = setTimeout(module.show, settings.delay.show);
          },
          hide: function () {
            module.verbose('Delaying hide event to ensure user intent');
            clearTimeout(module.timer);
            module.timer = setTimeout(module.hide, settings.delay.hide);
          }
        },

        escape: {
          value: function (value) {
            var
                multipleValues = $.isArray(value),
                stringValue = (typeof value === 'string'),
                isUnparsable = (!stringValue && !multipleValues),
                hasQuotes = (stringValue && value.search(regExp.quote) !== -1),
                values = []
            ;
            if (isUnparsable || !hasQuotes) {
              return value;
            }
            module.debug('Encoding quote values for use in select', value);
            if (multipleValues) {
              $.each(value, function (index, value) {
                values.push(value.replace(regExp.quote, '&quot;'));
              });
              return values;
            }
            return value.replace(regExp.quote, '&quot;');
          },
          string: function (text) {
            text = String(text);
            return text.replace(regExp.escape, '\\$&');
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;
    return (returnedValue !== undefined)
        ? returnedValue
        : $allModules
        ;
  };

  $.fn.dropdown.settings = {

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    on: 'click',    // what event should show menu action on item selection
    action: 'activate', // action on item selection (nothing, activate, select, combo, hide, function(){})

    apiSettings: false,
    selectOnKeydown: true,       // Whether selection should occur automatically when keyboard shortcuts used
    minCharacters: 0,          // Minimum characters required to trigger API call

    filterRemoteData: false,      // Whether API results should be filtered after being returned for query term
    saveRemoteData: true,       // Whether remote name/value pairs should be stored in sessionStorage to allow remote data to be restored on page refresh

    throttle: 200,        // How long to wait after last user input to search remotely

    context: window,     // Context to use when determining if on screen
    direction: 'auto',     // Whether dropdown should always open in one direction
    keepOnScreen: true,       // Whether dropdown should check whether it is on screen before showing

    match: 'both',     // what to match against with search selection (both, text, or label)
    fullTextSearch: false,      // search anywhere in value (set to 'exact' to require exact matches)

    placeholder: 'auto',     // whether to convert blank <select> values to placeholder text
    preserveHTML: true,       // preserve html when selecting value
    sortSelect: false,      // sort selection on init

    forceSelection: true,       // force a choice on blur with search selection

    allowAdditions: false,      // whether multiple select should allow user added values
    hideAdditions: true,      // whether or not to hide special message prompting a user they can enter a value

    maxSelections: false,      // When set to a number limits the number of selections to this count
    useLabels: true,       // whether multiple select should filter currently active selections from choices
    delimiter: ',',        // when multiselect uses normal <input> the values will be delimited with this character

    showOnFocus: true,       // show menu on focus
    allowReselection: false,      // whether current value should trigger callbacks when reselected
    allowTab: true,       // add tabindex to element
    allowCategorySelection: false,      // allow elements with sub-menus to be selected

    fireOnInit: false,      // Whether callbacks should fire when initializing dropdown values

    transition: 'auto',     // auto transition will slide down or up based on direction
    duration: 200,        // duration of transition

    glyphWidth: 1.037,      // widest glyph width in em (W is 1.037 em) used to calculate multiselect input width

    // label settings on multi-select
    label: {
      transition: 'scale',
      duration: 200,
      variation: false
    },

    // delay before event
    delay: {
      hide: 300,
      show: 200,
      search: 20,
      touch: 50
    },

    /* Callbacks */
    onChange: function (value, text, $selected) {
    },
    onAdd: function (value, text, $selected) {
    },
    onRemove: function (value, text, $selected) {
    },

    onLabelSelect: function ($selectedLabels) {
    },
    onLabelCreate: function (value, text) {
      return $(this);
    },
    onLabelRemove: function (value) {
      return true;
    },
    onNoResults: function (searchTerm) {
      return true;
    },
    onShow: function () {
    },
    onHide: function () {
    },

    /* Component */
    name: 'Dropdown',
    namespace: 'dropdown',

    message: {
      addResult: 'Add <b>{term}</b>',
      count: '{count} selected',
      maxSelections: 'Max {maxCount} selections',
      noResults: 'No results found.',
      serverError: 'There was an error contacting the server'
    },

    error: {
      action: 'You called a dropdown action that was not defined',
      alreadySetup: 'Once a select has been initialized behaviors must be called on the created ui dropdown',
      labels: 'Allowing user additions currently requires the use of labels.',
      missingMultiple: '<select> requires multiple property to be set to correctly preserve multiple values',
      method: 'The method you called is not defined.',
      noAPI: 'The API module is required to load resources remotely',
      noStorage: 'Saving remote data requires session storage',
      noTransition: 'This module requires ui transitions <https://github.com/Semantic-Org/UI-Transition>'
    },

    regExp: {
      escape: /[-[\]{}()*+?.,\\^$|#\s]/g,
      quote: /"/g
    },

    metadata: {
      defaultText: 'defaultText',
      defaultValue: 'defaultValue',
      placeholderText: 'placeholder',
      text: 'text',
      value: 'value'
    },

    // property names for remote query
    fields: {
      remoteValues: 'results',  // grouping for api results
      values: 'values',   // grouping for all dropdown values
      disabled: 'disabled', // whether value should be disabled
      name: 'name',     // displayed dropdown text
      value: 'value',    // actual dropdown value
      text: 'text'      // displayed text when selected
    },

    keys: {
      backspace: 8,
      delimiter: 188, // comma
      deleteKey: 46,
      enter: 13,
      escape: 27,
      pageUp: 33,
      pageDown: 34,
      leftArrow: 37,
      upArrow: 38,
      rightArrow: 39,
      downArrow: 40
    },

    selector: {
      addition: '.addition',
      dropdown: '.ui.dropdown',
      hidden: '.hidden',
      icon: '> .dropdown.icon',
      input: '> input[type="hidden"], > select',
      item: '.item',
      label: '> .label',
      remove: '> .label > .delete.icon',
      siblingLabel: '.label',
      menu: '.menu',
      message: '.message',
      menuIcon: '.dropdown.icon',
      search: 'input.search, .menu > .search > input, .menu input.search',
      sizer: '> input.sizer',
      text: '> .text:not(.icon)',
      unselectable: '.disabled, .filtered'
    },

    className: {
      active: 'active',
      addition: 'addition',
      animating: 'animating',
      disabled: 'disabled',
      empty: 'empty',
      dropdown: 'ui dropdown',
      filtered: 'filtered',
      hidden: 'hidden transition',
      item: 'item',
      label: 'ui label',
      loading: 'loading',
      menu: 'menu',
      message: 'message',
      multiple: 'multiple',
      placeholder: 'default',
      sizer: 'sizer',
      search: 'search',
      selected: 'selected',
      selection: 'selection',
      upward: 'upward',
      visible: 'visible'
    }

  };

  /* Templates */
  $.fn.dropdown.settings.templates = {

    // generates dropdown from select values
    dropdown: function (select) {
      var
          placeholder = select.placeholder || false,
          values = select.values || {},
          html = ''
      ;
      html += '<i class="dropdown icon"></i>';
      if (select.placeholder) {
        html += '<div class="default text">' + placeholder + '</div>';
      }
      else {
        html += '<div class="text"></div>';
      }
      html += '<div class="menu">';
      $.each(select.values, function (index, option) {
        html += (option.disabled)
            ? '<div class="disabled item" data-value="' + option.value + '">'
            + option.name + '</div>'
            : '<div class="item" data-value="' + option.value + '">'
            + option.name + '</div>'
        ;
      });
      html += '</div>';
      return html;
    },

    // generates just menu from select
    menu: function (response, fields) {
      var
          values = response[fields.values] || {},
          html = ''
      ;
      $.each(values, function (index, option) {
        var
            maybeText = (option[fields.text])
                ? 'data-text="' + option[fields.text] + '"'
                : '',
            maybeDisabled = (option[fields.disabled])
                ? 'disabled '
                : ''
        ;
        html += '<div class="' + maybeDisabled + 'item" data-value="'
            + option[fields.value] + '"' + maybeText + '>'
        html += option[fields.name];
        html += '</div>';
      });
      return html;
    },

    // generates label for multiselect
    label: function (value, text) {
      return text + '<i class="delete icon"></i>';
    },

    // generates messages like "No results"
    message: function (message) {
      return message;
    },

    // generates user addition to selection menu
    addition: function (choice) {
      return choice;
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Embed
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.embed = function (parameters) {

    var
        $allModules = $(this),

        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.embed.settings, parameters)
              : $.extend({}, $.fn.embed.settings),

          selector = settings.selector,
          className = settings.className,
          sources = settings.sources,
          error = settings.error,
          metadata = settings.metadata,
          namespace = settings.namespace,
          templates = settings.templates,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $window = $(window),
          $module = $(this),
          $placeholder = $module.find(selector.placeholder),
          $icon = $module.find(selector.icon),
          $embed = $module.find(selector.embed),

          element = this,
          instance = $module.data(moduleNamespace),
          module
      ;

      module = {

        initialize: function () {
          module.debug('Initializing embed');
          module.determine.autoplay();
          module.create();
          module.bind.events();
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous instance of embed');
          module.reset();
          $module
          .removeData(moduleNamespace)
          .off(eventNamespace)
          ;
        },

        refresh: function () {
          module.verbose('Refreshing selector cache');
          $placeholder = $module.find(selector.placeholder);
          $icon = $module.find(selector.icon);
          $embed = $module.find(selector.embed);
        },

        bind: {
          events: function () {
            if (module.has.placeholder()) {
              module.debug('Adding placeholder events');
              $module
              .on('click' + eventNamespace, selector.placeholder,
                  module.createAndShow)
              .on('click' + eventNamespace, selector.icon, module.createAndShow)
              ;
            }
          }
        },

        create: function () {
          var
              placeholder = module.get.placeholder()
          ;
          if (placeholder) {
            module.createPlaceholder();
          }
          else {
            module.createAndShow();
          }
        },

        createPlaceholder: function (placeholder) {
          var
              icon = module.get.icon(),
              url = module.get.url(),
              embed = module.generate.embed(url)
          ;
          placeholder = placeholder || module.get.placeholder();
          $module.html(templates.placeholder(placeholder, icon));
          module.debug('Creating placeholder for embed', placeholder, icon);
        },

        createEmbed: function (url) {
          module.refresh();
          url = url || module.get.url();
          $embed = $('<div/>')
          .addClass(className.embed)
          .html(module.generate.embed(url))
          .appendTo($module)
          ;
          settings.onCreate.call(element, url);
          module.debug('Creating embed object', $embed);
        },

        changeEmbed: function (url) {
          $embed
          .html(module.generate.embed(url))
          ;
        },

        createAndShow: function () {
          module.createEmbed();
          module.show();
        },

        // sets new embed
        change: function (source, id, url) {
          module.debug('Changing video to ', source, id, url);
          $module
          .data(metadata.source, source)
          .data(metadata.id, id)
          ;
          if (url) {
            $module.data(metadata.url, url);
          }
          else {
            $module.removeData(metadata.url);
          }
          if (module.has.embed()) {
            module.changeEmbed();
          }
          else {
            module.create();
          }
        },

        // clears embed
        reset: function () {
          module.debug('Clearing embed and showing placeholder');
          module.remove.active();
          module.remove.embed();
          module.showPlaceholder();
          settings.onReset.call(element);
        },

        // shows current embed
        show: function () {
          module.debug('Showing embed');
          module.set.active();
          settings.onDisplay.call(element);
        },

        hide: function () {
          module.debug('Hiding embed');
          module.showPlaceholder();
        },

        showPlaceholder: function () {
          module.debug('Showing placeholder image');
          module.remove.active();
          settings.onPlaceholderDisplay.call(element);
        },

        get: {
          id: function () {
            return settings.id || $module.data(metadata.id);
          },
          placeholder: function () {
            return settings.placeholder || $module.data(metadata.placeholder);
          },
          icon: function () {
            return (settings.icon)
                ? settings.icon
                : ($module.data(metadata.icon) !== undefined)
                    ? $module.data(metadata.icon)
                    : module.determine.icon()
                ;
          },
          source: function (url) {
            return (settings.source)
                ? settings.source
                : ($module.data(metadata.source) !== undefined)
                    ? $module.data(metadata.source)
                    : module.determine.source()
                ;
          },
          type: function () {
            var source = module.get.source();
            return (sources[source] !== undefined)
                ? sources[source].type
                : false
                ;
          },
          url: function () {
            return (settings.url)
                ? settings.url
                : ($module.data(metadata.url) !== undefined)
                    ? $module.data(metadata.url)
                    : module.determine.url()
                ;
          }
        },

        determine: {
          autoplay: function () {
            if (module.should.autoplay()) {
              settings.autoplay = true;
            }
          },
          source: function (url) {
            var
                matchedSource = false
            ;
            url = url || module.get.url();
            if (url) {
              $.each(sources, function (name, source) {
                if (url.search(source.domain) !== -1) {
                  matchedSource = name;
                  return false;
                }
              });
            }
            return matchedSource;
          },
          icon: function () {
            var
                source = module.get.source()
            ;
            return (sources[source] !== undefined)
                ? sources[source].icon
                : false
                ;
          },
          url: function () {
            var
                id = settings.id || $module.data(metadata.id),
                source = settings.source || $module.data(metadata.source),
                url
            ;
            url = (sources[source] !== undefined)
                ? sources[source].url.replace('{id}', id)
                : false
            ;
            if (url) {
              $module.data(metadata.url, url);
            }
            return url;
          }
        },

        set: {
          active: function () {
            $module.addClass(className.active);
          }
        },

        remove: {
          active: function () {
            $module.removeClass(className.active);
          },
          embed: function () {
            $embed.empty();
          }
        },

        encode: {
          parameters: function (parameters) {
            var
                urlString = [],
                index
            ;
            for (index in parameters) {
              urlString.push(
                  encodeURIComponent(index) + '=' + encodeURIComponent(
                      parameters[index]));
            }
            return urlString.join('&amp;');
          }
        },

        generate: {
          embed: function (url) {
            module.debug('Generating embed html');
            var
                source = module.get.source(),
                html,
                parameters
            ;
            url = module.get.url(url);
            if (url) {
              parameters = module.generate.parameters(source);
              html = templates.iframe(url, parameters);
            }
            else {
              module.error(error.noURL, $module);
            }
            return html;
          },
          parameters: function (source, extraParameters) {
            var
                parameters = (sources[source] && sources[source].parameters
                !== undefined)
                    ? sources[source].parameters(settings)
                    : {}
            ;
            extraParameters = extraParameters || settings.parameters;
            if (extraParameters) {
              parameters = $.extend({}, parameters, extraParameters);
            }
            parameters = settings.onEmbed(parameters);
            return module.encode.parameters(parameters);
          }
        },

        has: {
          embed: function () {
            return ($embed.length > 0);
          },
          placeholder: function () {
            return settings.placeholder || $module.data(metadata.placeholder);
          }
        },

        should: {
          autoplay: function () {
            return (settings.autoplay === 'auto')
                ? (settings.placeholder || $module.data(metadata.placeholder)
                !== undefined)
                : settings.autoplay
                ;
          }
        },

        is: {
          video: function () {
            return module.get.type() == 'video';
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;
    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.embed.settings = {

    name: 'Embed',
    namespace: 'embed',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    icon: false,
    source: false,
    url: false,
    id: false,

    // standard video settings
    autoplay: 'auto',
    color: '#444444',
    hd: true,
    brandedUI: false,

    // additional parameters to include with the embed
    parameters: false,

    onDisplay: function () {
    },
    onPlaceholderDisplay: function () {
    },
    onReset: function () {
    },
    onCreate: function (url) {
    },
    onEmbed: function (parameters) {
      return parameters;
    },

    metadata: {
      id: 'id',
      icon: 'icon',
      placeholder: 'placeholder',
      source: 'source',
      url: 'url'
    },

    error: {
      noURL: 'No URL specified',
      method: 'The method you called is not defined'
    },

    className: {
      active: 'active',
      embed: 'embed'
    },

    selector: {
      embed: '.embed',
      placeholder: '.placeholder',
      icon: '.icon'
    },

    sources: {
      youtube: {
        name: 'youtube',
        type: 'video',
        icon: 'video play',
        domain: 'youtube.com',
        url: '//www.youtube.com/embed/{id}',
        parameters: function (settings) {
          return {
            autohide: !settings.brandedUI,
            autoplay: settings.autoplay,
            color: settings.color || undefined,
            hq: settings.hd,
            jsapi: settings.api,
            modestbranding: !settings.brandedUI
          };
        }
      },
      vimeo: {
        name: 'vimeo',
        type: 'video',
        icon: 'video play',
        domain: 'vimeo.com',
        url: '//player.vimeo.com/video/{id}',
        parameters: function (settings) {
          return {
            api: settings.api,
            autoplay: settings.autoplay,
            byline: settings.brandedUI,
            color: settings.color || undefined,
            portrait: settings.brandedUI,
            title: settings.brandedUI
          };
        }
      }
    },

    templates: {
      iframe: function (url, parameters) {
        var src = url;
        if (parameters) {
          src += '?' + parameters;
        }
        return ''
            + '<iframe src="' + src + '"'
            + ' width="100%" height="100%"'
            + ' frameborder="0" scrolling="no" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>'
            ;
      },
      placeholder: function (image, icon) {
        var
            html = ''
        ;
        if (icon) {
          html += '<i class="' + icon + ' icon"></i>';
        }
        if (image) {
          html += '<img class="placeholder" src="' + image + '">';
        }
        return html;
      }
    },

    // NOT YET IMPLEMENTED
    api: false,
    onPause: function () {
    },
    onPlay: function () {
    },
    onStop: function () {
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Modal
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.modal = function (parameters) {
    var
        $allModules = $(this),
        $window = $(window),
        $document = $(document),
        $body = $('body'),

        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) {
              setTimeout(callback, 0);
            },

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.modal.settings, parameters)
              : $.extend({}, $.fn.modal.settings),

          selector = settings.selector,
          className = settings.className,
          namespace = settings.namespace,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $context = $(settings.context),
          $close = $module.find(selector.close),

          $allModals,
          $otherModals,
          $focusedElement,
          $dimmable,
          $dimmer,

          element = this,
          instance = $module.data(moduleNamespace),

          ignoreRepeatedEvents = false,

          elementEventNamespace,
          id,
          observer,
          module
      ;
      module = {

        initialize: function () {
          module.verbose('Initializing dimmer', $context);

          module.create.id();
          module.create.dimmer();
          module.refreshModals();

          module.bind.events();
          if (settings.observeChanges) {
            module.observeChanges();
          }
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of modal');
          instance = module;
          $module
          .data(moduleNamespace, instance)
          ;
        },

        create: {
          dimmer: function () {
            var
                defaultSettings = {
                  debug: settings.debug,
                  dimmerName: 'modals',
                  duration: {
                    show: settings.duration,
                    hide: settings.duration
                  }
                },
                dimmerSettings = $.extend(true, defaultSettings,
                    settings.dimmerSettings)
            ;
            if (settings.inverted) {
              dimmerSettings.variation = (dimmerSettings.variation
              !== undefined)
                  ? dimmerSettings.variation + ' inverted'
                  : 'inverted'
              ;
            }
            if ($.fn.dimmer === undefined) {
              module.error(error.dimmer);
              return;
            }
            module.debug('Creating dimmer with settings', dimmerSettings);
            $dimmable = $context.dimmer(dimmerSettings);
            if (settings.detachable) {
              module.verbose('Modal is detachable, moving content into dimmer');
              $dimmable.dimmer('add content', $module);
            }
            else {
              module.set.undetached();
            }
            if (settings.blurring) {
              $dimmable.addClass(className.blurring);
            }
            $dimmer = $dimmable.dimmer('get dimmer');
          },
          id: function () {
            id = (Math.random().toString(16) + '000000000').substr(2, 8);
            elementEventNamespace = '.' + id;
            module.verbose('Creating unique id for element', id);
          }
        },

        destroy: function () {
          module.verbose('Destroying previous modal');
          $module
          .removeData(moduleNamespace)
          .off(eventNamespace)
          ;
          $window.off(elementEventNamespace);
          $dimmer.off(elementEventNamespace);
          $close.off(eventNamespace);
          $context.dimmer('destroy');
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            observer = new MutationObserver(function (mutations) {
              module.debug('DOM tree modified, refreshing');
              module.refresh();
            });
            observer.observe(element, {
              childList: true,
              subtree: true
            });
            module.debug('Setting up mutation observer', observer);
          }
        },

        refresh: function () {
          module.remove.scrolling();
          module.cacheSizes();
          module.set.screenHeight();
          module.set.type();
          module.set.position();
        },

        refreshModals: function () {
          $otherModals = $module.siblings(selector.modal);
          $allModals = $otherModals.add($module);
        },

        attachEvents: function (selector, event) {
          var
              $toggle = $(selector)
          ;
          event = $.isFunction(module[event])
              ? module[event]
              : module.toggle
          ;
          if ($toggle.length > 0) {
            module.debug('Attaching modal events to element', selector, event);
            $toggle
            .off(eventNamespace)
            .on('click' + eventNamespace, event)
            ;
          }
          else {
            module.error(error.notFound, selector);
          }
        },

        bind: {
          events: function () {
            module.verbose('Attaching events');
            $module
            .on('click' + eventNamespace, selector.close, module.event.close)
            .on('click' + eventNamespace, selector.approve,
                module.event.approve)
            .on('click' + eventNamespace, selector.deny, module.event.deny)
            ;
            $window
            .on('resize' + elementEventNamespace, module.event.resize)
            ;
          }
        },

        get: {
          id: function () {
            return (Math.random().toString(16) + '000000000').substr(2, 8);
          }
        },

        event: {
          approve: function () {
            if (ignoreRepeatedEvents || settings.onApprove.call(element,
                    $(this)) === false) {
              module.verbose('Approve callback returned false cancelling hide');
              return;
            }
            ignoreRepeatedEvents = true;
            module.hide(function () {
              ignoreRepeatedEvents = false;
            });
          },
          deny: function () {
            if (ignoreRepeatedEvents || settings.onDeny.call(element, $(this))
                === false) {
              module.verbose('Deny callback returned false cancelling hide');
              return;
            }
            ignoreRepeatedEvents = true;
            module.hide(function () {
              ignoreRepeatedEvents = false;
            });
          },
          close: function () {
            module.hide();
          },
          click: function (event) {
            var
                $target = $(event.target),
                isInModal = ($target.closest(selector.modal).length > 0),
                isInDOM = $.contains(document.documentElement, event.target)
            ;
            if (!isInModal && isInDOM) {
              module.debug('Dimmer clicked, hiding all modals');
              if (module.is.active()) {
                module.remove.clickaway();
                if (settings.allowMultiple) {
                  module.hide();
                }
                else {
                  module.hideAll();
                }
              }
            }
          },
          debounce: function (method, delay) {
            clearTimeout(module.timer);
            module.timer = setTimeout(method, delay);
          },
          keyboard: function (event) {
            var
                keyCode = event.which,
                escapeKey = 27
            ;
            if (keyCode == escapeKey) {
              if (settings.closable) {
                module.debug('Escape key pressed hiding modal');
                module.hide();
              }
              else {
                module.debug(
                    'Escape key pressed, but closable is set to false');
              }
              event.preventDefault();
            }
          },
          resize: function () {
            if ($dimmable.dimmer('is active')) {
              requestAnimationFrame(module.refresh);
            }
          }
        },

        toggle: function () {
          if (module.is.active() || module.is.animating()) {
            module.hide();
          }
          else {
            module.show();
          }
        },

        show: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          module.refreshModals();
          module.showModal(callback);
        },

        hide: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          module.refreshModals();
          module.hideModal(callback);
        },

        showModal: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (module.is.animating() || !module.is.active()) {

            module.showDimmer();
            module.cacheSizes();
            module.set.position();
            module.set.screenHeight();
            module.set.type();
            module.set.clickaway();

            if (!settings.allowMultiple && module.others.active()) {
              module.hideOthers(module.showModal);
            }
            else {
              settings.onShow.call(element);
              if (settings.transition && $.fn.transition !== undefined
                  && $module.transition('is supported')) {
                module.debug('Showing modal with css animations');
                $module
                .transition({
                  debug: settings.debug,
                  animation: settings.transition + ' in',
                  queue: settings.queue,
                  duration: settings.duration,
                  useFailSafe: true,
                  onComplete: function () {
                    settings.onVisible.apply(element);
                    if (settings.keyboardShortcuts) {
                      module.add.keyboardShortcuts();
                    }
                    module.save.focus();
                    module.set.active();
                    if (settings.autofocus) {
                      module.set.autofocus();
                    }
                    callback();
                  }
                })
                ;
              }
              else {
                module.error(error.noTransition);
              }
            }
          }
          else {
            module.debug('Modal is already visible');
          }
        },

        hideModal: function (callback, keepDimmed) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          module.debug('Hiding modal');
          if (settings.onHide.call(element, $(this)) === false) {
            module.verbose('Hide callback returned false cancelling hide');
            return;
          }

          if (module.is.animating() || module.is.active()) {
            if (settings.transition && $.fn.transition !== undefined
                && $module.transition('is supported')) {
              module.remove.active();
              $module
              .transition({
                debug: settings.debug,
                animation: settings.transition + ' out',
                queue: settings.queue,
                duration: settings.duration,
                useFailSafe: true,
                onStart: function () {
                  if (!module.others.active() && !keepDimmed) {
                    module.hideDimmer();
                  }
                  if (settings.keyboardShortcuts) {
                    module.remove.keyboardShortcuts();
                  }
                },
                onComplete: function () {
                  settings.onHidden.call(element);
                  module.restore.focus();
                  callback();
                }
              })
              ;
            }
            else {
              module.error(error.noTransition);
            }
          }
        },

        showDimmer: function () {
          if ($dimmable.dimmer('is animating') || !$dimmable.dimmer(
                  'is active')) {
            module.debug('Showing dimmer');
            $dimmable.dimmer('show');
          }
          else {
            module.debug('Dimmer already visible');
          }
        },

        hideDimmer: function () {
          if ($dimmable.dimmer('is animating') || ($dimmable.dimmer(
                  'is active'))) {
            $dimmable.dimmer('hide', function () {
              module.remove.clickaway();
              module.remove.screenHeight();
            });
          }
          else {
            module.debug('Dimmer is not visible cannot hide');
            return;
          }
        },

        hideAll: function (callback) {
          var
              $visibleModals = $allModals.filter(
                  '.' + className.active + ', .' + className.animating)
          ;
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if ($visibleModals.length > 0) {
            module.debug('Hiding all visible modals');
            module.hideDimmer();
            $visibleModals
            .modal('hide modal', callback)
            ;
          }
        },

        hideOthers: function (callback) {
          var
              $visibleModals = $otherModals.filter(
                  '.' + className.active + ', .' + className.animating)
          ;
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if ($visibleModals.length > 0) {
            module.debug('Hiding other modals', $otherModals);
            $visibleModals
            .modal('hide modal', callback, true)
            ;
          }
        },

        others: {
          active: function () {
            return ($otherModals.filter('.' + className.active).length > 0);
          },
          animating: function () {
            return ($otherModals.filter('.' + className.animating).length > 0);
          }
        },

        add: {
          keyboardShortcuts: function () {
            module.verbose('Adding keyboard shortcuts');
            $document
            .on('keyup' + eventNamespace, module.event.keyboard)
            ;
          }
        },

        save: {
          focus: function () {
            $focusedElement = $(document.activeElement).blur();
          }
        },

        restore: {
          focus: function () {
            if ($focusedElement && $focusedElement.length > 0) {
              $focusedElement.focus();
            }
          }
        },

        remove: {
          active: function () {
            $module.removeClass(className.active);
          },
          clickaway: function () {
            if (settings.closable) {
              $dimmer
              .off('click' + elementEventNamespace)
              ;
            }
          },
          bodyStyle: function () {
            if ($body.attr('style') === '') {
              module.verbose('Removing style attribute');
              $body.removeAttr('style');
            }
          },
          screenHeight: function () {
            module.debug('Removing page height');
            $body
            .css('height', '')
            ;
          },
          keyboardShortcuts: function () {
            module.verbose('Removing keyboard shortcuts');
            $document
            .off('keyup' + eventNamespace)
            ;
          },
          scrolling: function () {
            $dimmable.removeClass(className.scrolling);
            $module.removeClass(className.scrolling);
          }
        },

        cacheSizes: function () {
          var
              modalHeight = $module.outerHeight()
          ;
          if (module.cache === undefined || modalHeight !== 0) {
            module.cache = {
              pageHeight: $(document).outerHeight(),
              height: modalHeight + settings.offset,
              contextHeight: (settings.context == 'body')
                  ? $(window).height()
                  : $dimmable.height()
            };
          }
          module.debug('Caching modal and container sizes', module.cache);
        },

        can: {
          fit: function () {
            return ( ( module.cache.height + (settings.padding * 2) )
            < module.cache.contextHeight);
          }
        },

        is: {
          active: function () {
            return $module.hasClass(className.active);
          },
          animating: function () {
            return $module.transition('is supported')
                ? $module.transition('is animating')
                : $module.is(':visible')
                ;
          },
          scrolling: function () {
            return $dimmable.hasClass(className.scrolling);
          },
          modernBrowser: function () {
            // appName for IE11 reports 'Netscape' can no longer use
            return !(window.ActiveXObject || "ActiveXObject" in window);
          }
        },

        set: {
          autofocus: function () {
            var
                $inputs = $module.find('[tabindex], :input').filter(':visible'),
                $autofocus = $inputs.filter('[autofocus]'),
                $input = ($autofocus.length > 0)
                    ? $autofocus.first()
                    : $inputs.first()
            ;
            if ($input.length > 0) {
              $input.focus();
            }
          },
          clickaway: function () {
            if (settings.closable) {
              $dimmer
              .on('click' + elementEventNamespace, module.event.click)
              ;
            }
          },
          screenHeight: function () {
            if (module.can.fit()) {
              $body.css('height', '');
            }
            else {
              module.debug(
                  'Modal is taller than page content, resizing page height');
              $body
              .css('height', module.cache.height + (settings.padding * 2))
              ;
            }
          },
          active: function () {
            $module.addClass(className.active);
          },
          scrolling: function () {
            $dimmable.addClass(className.scrolling);
            $module.addClass(className.scrolling);
          },
          type: function () {
            if (module.can.fit()) {
              module.verbose('Modal fits on screen');
              if (!module.others.active() && !module.others.animating()) {
                module.remove.scrolling();
              }
            }
            else {
              module.verbose('Modal cannot fit on screen setting to scrolling');
              module.set.scrolling();
            }
          },
          position: function () {
            module.verbose('Centering modal on page', module.cache);
            if (module.can.fit()) {
              $module
              .css({
                top: '',
                marginTop: -(module.cache.height / 2)
              })
              ;
            }
            else {
              $module
              .css({
                marginTop: '',
                top: $document.scrollTop()
              })
              ;
            }
          },
          undetached: function () {
            $dimmable.addClass(className.undetached);
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.modal.settings = {

    name: 'Modal',
    namespace: 'modal',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    observeChanges: false,

    allowMultiple: false,
    detachable: true,
    closable: true,
    autofocus: true,

    inverted: false,
    blurring: false,

    dimmerSettings: {
      closable: false,
      useCSS: true
    },

    // whether to use keyboard shortcuts
    keyboardShortcuts: true,

    context: 'body',

    queue: false,
    duration: 500,
    offset: 0,
    transition: 'scale',

    // padding with edge of page
    padding: 50,

    // called before show animation
    onShow: function () {
    },

    // called after show animation
    onVisible: function () {
    },

    // called before hide animation
    onHide: function () {
      return true;
    },

    // called after hide animation
    onHidden: function () {
    },

    // called after approve selector match
    onApprove: function () {
      return true;
    },

    // called after deny selector match
    onDeny: function () {
      return true;
    },

    selector: {
      close: '> .close',
      approve: '.actions .positive, .actions .approve, .actions .ok',
      deny: '.actions .negative, .actions .deny, .actions .cancel',
      modal: '.ui.modal'
    },
    error: {
      dimmer: 'UI Dimmer, a required component is not included in this page',
      method: 'The method you called is not defined.',
      notFound: 'The element you specified could not be found'
    },
    className: {
      active: 'active',
      animating: 'animating',
      blurring: 'blurring',
      scrolling: 'scrolling',
      undetached: 'undetached'
    }
  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Nag
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.nag = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;
    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.nag.settings, parameters)
              : $.extend({}, $.fn.nag.settings),

          className = settings.className,
          selector = settings.selector,
          error = settings.error,
          namespace = settings.namespace,

          eventNamespace = '.' + namespace,
          moduleNamespace = namespace + '-module',

          $module = $(this),

          $close = $module.find(selector.close),
          $context = (settings.context)
              ? $(settings.context)
              : $('body'),

          element = this,
          instance = $module.data(moduleNamespace),

          moduleOffset,
          moduleHeight,

          contextWidth,
          contextHeight,
          contextOffset,

          yOffset,
          yPosition,

          timer,
          module,

          requestAnimationFrame = window.requestAnimationFrame
              || window.mozRequestAnimationFrame
              || window.webkitRequestAnimationFrame
              || window.msRequestAnimationFrame
              || function (callback) {
                setTimeout(callback, 0);
              }
      ;
      module = {

        initialize: function () {
          module.verbose('Initializing element');

          $module
          .on('click' + eventNamespace, selector.close, module.dismiss)
          .data(moduleNamespace, module)
          ;

          if (settings.detachable && $module.parent()[0] !== $context[0]) {
            $module
            .detach()
            .prependTo($context)
            ;
          }

          if (settings.displayTime > 0) {
            setTimeout(module.hide, settings.displayTime);
          }
          module.show();
        },

        destroy: function () {
          module.verbose('Destroying instance');
          $module
          .removeData(moduleNamespace)
          .off(eventNamespace)
          ;
        },

        show: function () {
          if (module.should.show() && !$module.is(':visible')) {
            module.debug('Showing nag', settings.animation.show);
            if (settings.animation.show == 'fade') {
              $module
              .fadeIn(settings.duration, settings.easing)
              ;
            }
            else {
              $module
              .slideDown(settings.duration, settings.easing)
              ;
            }
          }
        },

        hide: function () {
          module.debug('Showing nag', settings.animation.hide);
          if (settings.animation.show == 'fade') {
            $module
            .fadeIn(settings.duration, settings.easing)
            ;
          }
          else {
            $module
            .slideUp(settings.duration, settings.easing)
            ;
          }
        },

        onHide: function () {
          module.debug('Removing nag', settings.animation.hide);
          $module.remove();
          if (settings.onHide) {
            settings.onHide();
          }
        },

        dismiss: function (event) {
          if (settings.storageMethod) {
            module.storage.set(settings.key, settings.value);
          }
          module.hide();
          event.stopImmediatePropagation();
          event.preventDefault();
        },

        should: {
          show: function () {
            if (settings.persist) {
              module.debug('Persistent nag is set, can show nag');
              return true;
            }
            if (module.storage.get(settings.key) != settings.value.toString()) {
              module.debug('Stored value is not set, can show nag',
                  module.storage.get(settings.key));
              return true;
            }
            module.debug('Stored value is set, cannot show nag',
                module.storage.get(settings.key));
            return false;
          }
        },

        get: {
          storageOptions: function () {
            var
                options = {}
            ;
            if (settings.expires) {
              options.expires = settings.expires;
            }
            if (settings.domain) {
              options.domain = settings.domain;
            }
            if (settings.path) {
              options.path = settings.path;
            }
            return options;
          }
        },

        clear: function () {
          module.storage.remove(settings.key);
        },

        storage: {
          set: function (key, value) {
            var
                options = module.get.storageOptions()
            ;
            if (settings.storageMethod == 'localstorage' && window.localStorage
                !== undefined) {
              window.localStorage.setItem(key, value);
              module.debug('Value stored using local storage', key, value);
            }
            else if (settings.storageMethod == 'sessionstorage'
                && window.sessionStorage !== undefined) {
              window.sessionStorage.setItem(key, value);
              module.debug('Value stored using session storage', key, value);
            }
            else if ($.cookie !== undefined) {
              $.cookie(key, value, options);
              module.debug('Value stored using cookie', key, value, options);
            }
            else {
              module.error(error.noCookieStorage);
              return;
            }
          },
          get: function (key, value) {
            var
                storedValue
            ;
            if (settings.storageMethod == 'localstorage' && window.localStorage
                !== undefined) {
              storedValue = window.localStorage.getItem(key);
            }
            else if (settings.storageMethod == 'sessionstorage'
                && window.sessionStorage !== undefined) {
              storedValue = window.sessionStorage.getItem(key);
            }
            // get by cookie
            else if ($.cookie !== undefined) {
              storedValue = $.cookie(key);
            }
            else {
              module.error(error.noCookieStorage);
            }
            if (storedValue == 'undefined' || storedValue == 'null'
                || storedValue === undefined || storedValue === null) {
              storedValue = undefined;
            }
            return storedValue;
          },
          remove: function (key) {
            var
                options = module.get.storageOptions()
            ;
            if (settings.storageMethod == 'localstorage' && window.localStorage
                !== undefined) {
              window.localStorage.removeItem(key);
            }
            else if (settings.storageMethod == 'sessionstorage'
                && window.sessionStorage !== undefined) {
              window.sessionStorage.removeItem(key);
            }
            // store by cookie
            else if ($.cookie !== undefined) {
              $.removeCookie(key, options);
            }
            else {
              module.error(error.noStorage);
            }
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.nag.settings = {

    name: 'Nag',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    namespace: 'Nag',

    // allows cookie to be overridden
    persist: false,

    // set to zero to require manually dismissal, otherwise hides on its own
    displayTime: 0,

    animation: {
      show: 'slide',
      hide: 'slide'
    },

    context: false,
    detachable: false,

    expires: 30,
    domain: false,
    path: '/',

    // type of storage to use
    storageMethod: 'cookie',

    // value to store in dismissed localstorage/cookie
    key: 'nag',
    value: 'dismiss',

    error: {
      noCookieStorage: '$.cookie is not included. A storage solution is required.',
      noStorage: 'Neither $.cookie or store is defined. A storage solution is required for storing state',
      method: 'The method you called is not defined.'
    },

    className: {
      bottom: 'bottom',
      fixed: 'fixed'
    },

    selector: {
      close: '.close.icon'
    },

    speed: 500,
    easing: 'easeOutQuad',

    onHide: function () {
    }

  };

// Adds easing
  $.extend($.easing, {
    easeOutQuad: function (x, t, b, c, d) {
      return -c * (t /= d) * (t - 2) + b;
    }
  });

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Popup
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.popup = function (parameters) {
    var
        $allModules = $(this),
        $document = $(document),
        $window = $(window),
        $body = $('body'),

        moduleSelector = $allModules.selector || '',

        hasTouch = (true),
        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        returnedValue
    ;
    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.popup.settings, parameters)
              : $.extend({}, $.fn.popup.settings),

          selector = settings.selector,
          className = settings.className,
          error = settings.error,
          metadata = settings.metadata,
          namespace = settings.namespace,

          eventNamespace = '.' + settings.namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $context = $(settings.context),
          $scrollContext = $(settings.scrollContext),
          $boundary = $(settings.boundary),
          $target = (settings.target)
              ? $(settings.target)
              : $module,

          $popup,
          $offsetParent,

          searchDepth = 0,
          triedPositions = false,
          openedWithTouch = false,

          element = this,
          instance = $module.data(moduleNamespace),

          documentObserver,
          elementNamespace,
          id,
          module
      ;

      module = {

        // binds events
        initialize: function () {
          module.debug('Initializing', $module);
          module.createID();
          module.bind.events();
          if (!module.exists() && settings.preserve) {
            module.create();
          }
          if (settings.observeChanges) {
            module.observeChanges();
          }
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance', module);
          instance = module;
          $module
          .data(moduleNamespace, instance)
          ;
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            documentObserver = new MutationObserver(
                module.event.documentChanged);
            documentObserver.observe(document, {
              childList: true,
              subtree: true
            });
            module.debug('Setting up mutation observer', documentObserver);
          }
        },

        refresh: function () {
          if (settings.popup) {
            $popup = $(settings.popup).eq(0);
          }
          else {
            if (settings.inline) {
              $popup = $target.nextAll(selector.popup).eq(0);
              settings.popup = $popup;
            }
          }
          if (settings.popup) {
            $popup.addClass(className.loading);
            $offsetParent = module.get.offsetParent();
            $popup.removeClass(className.loading);
            if (settings.movePopup && module.has.popup()
                && module.get.offsetParent($popup)[0] !== $offsetParent[0]) {
              module.debug(
                  'Moving popup to the same offset parent as activating element');
              $popup
              .detach()
              .appendTo($offsetParent)
              ;
            }
          }
          else {
            $offsetParent = (settings.inline)
                ? module.get.offsetParent($target)
                : module.has.popup()
                    ? module.get.offsetParent($popup)
                    : $body
            ;
          }
          if ($offsetParent.is('html') && $offsetParent[0] !== $body[0]) {
            module.debug('Setting page as offset parent');
            $offsetParent = $body;
          }
          if (module.get.variation()) {
            module.set.variation();
          }
        },

        reposition: function () {
          module.refresh();
          module.set.position();
        },

        destroy: function () {
          module.debug('Destroying previous module');
          if (documentObserver) {
            documentObserver.disconnect();
          }
          // remove element only if was created dynamically
          if ($popup && !settings.preserve) {
            module.removePopup();
          }
          // clear all timeouts
          clearTimeout(module.hideTimer);
          clearTimeout(module.showTimer);
          // remove events
          module.unbind.close();
          module.unbind.events();
          $module
          .removeData(moduleNamespace)
          ;
        },

        event: {
          start: function (event) {
            var
                delay = ($.isPlainObject(settings.delay))
                    ? settings.delay.show
                    : settings.delay
            ;
            clearTimeout(module.hideTimer);
            if (!openedWithTouch) {
              module.showTimer = setTimeout(module.show, delay);
            }
          },
          end: function () {
            var
                delay = ($.isPlainObject(settings.delay))
                    ? settings.delay.hide
                    : settings.delay
            ;
            clearTimeout(module.showTimer);
            module.hideTimer = setTimeout(module.hide, delay);
          },
          touchstart: function (event) {
            openedWithTouch = true;
            module.show();
          },
          resize: function () {
            if (module.is.visible()) {
              module.set.position();
            }
          },
          documentChanged: function (mutations) {
            [].forEach.call(mutations, function (mutation) {
              if (mutation.removedNodes) {
                [].forEach.call(mutation.removedNodes, function (node) {
                  if (node == element || $(node).find(element).length > 0) {
                    module.debug(
                        'Element removed from DOM, tearing down events');
                    module.destroy();
                  }
                });
              }
            });
          },
          hideGracefully: function (event) {
            var
                $target = $(event.target),
                isInDOM = $.contains(document.documentElement, event.target),
                inPopup = ($target.closest(selector.popup).length > 0)
            ;
            // don't close on clicks inside popup
            if (event && !inPopup && isInDOM) {
              module.debug('Click occurred outside popup hiding popup');
              module.hide();
            }
            else {
              module.debug('Click was inside popup, keeping popup open');
            }
          }
        },

        // generates popup html from metadata
        create: function () {
          var
              html = module.get.html(),
              title = module.get.title(),
              content = module.get.content()
          ;

          if (html || content || title) {
            module.debug('Creating pop-up html');
            if (!html) {
              html = settings.templates.popup({
                title: title,
                content: content
              });
            }
            $popup = $('<div/>')
            .addClass(className.popup)
            .data(metadata.activator, $module)
            .html(html)
            ;
            if (settings.inline) {
              module.verbose('Inserting popup element inline', $popup);
              $popup
              .insertAfter($module)
              ;
            }
            else {
              module.verbose('Appending popup element to body', $popup);
              $popup
              .appendTo($context)
              ;
            }
            module.refresh();
            module.set.variation();

            if (settings.hoverable) {
              module.bind.popup();
            }
            settings.onCreate.call($popup, element);
          }
          else if ($target.next(selector.popup).length !== 0) {
            module.verbose('Pre-existing popup found');
            settings.inline = true;
            settings.popup = $target.next(selector.popup).data(
                metadata.activator, $module);
            module.refresh();
            if (settings.hoverable) {
              module.bind.popup();
            }
          }
          else if (settings.popup) {
            $(settings.popup).data(metadata.activator, $module);
            module.verbose('Used popup specified in settings');
            module.refresh();
            if (settings.hoverable) {
              module.bind.popup();
            }
          }
          else {
            module.debug('No content specified skipping display', element);
          }
        },

        createID: function () {
          id = (Math.random().toString(16) + '000000000').substr(2, 8);
          elementNamespace = '.' + id;
          module.verbose('Creating unique id for element', id);
        },

        // determines popup state
        toggle: function () {
          module.debug('Toggling pop-up');
          if (module.is.hidden()) {
            module.debug('Popup is hidden, showing pop-up');
            module.unbind.close();
            module.show();
          }
          else {
            module.debug('Popup is visible, hiding pop-up');
            module.hide();
          }
        },

        show: function (callback) {
          callback = callback || function () {
              };
          module.debug('Showing pop-up', settings.transition);
          if (module.is.hidden() && !( module.is.active()
              && module.is.dropdown())) {
            if (!module.exists()) {
              module.create();
            }
            if (settings.onShow.call($popup, element) === false) {
              module.debug(
                  'onShow callback returned false, cancelling popup animation');
              return;
            }
            else if (!settings.preserve && !settings.popup) {
              module.refresh();
            }
            if ($popup && module.set.position()) {
              module.save.conditions();
              if (settings.exclusive) {
                module.hideAll();
              }
              module.animate.show(callback);
            }
          }
        },

        hide: function (callback) {
          callback = callback || function () {
              };
          if (module.is.visible() || module.is.animating()) {
            if (settings.onHide.call($popup, element) === false) {
              module.debug(
                  'onHide callback returned false, cancelling popup animation');
              return;
            }
            module.remove.visible();
            module.unbind.close();
            module.restore.conditions();
            module.animate.hide(callback);
          }
        },

        hideAll: function () {
          $(selector.popup)
          .filter('.' + className.visible)
          .each(function () {
            $(this)
            .data(metadata.activator)
            .popup('hide')
            ;
          })
          ;
        },
        exists: function () {
          if (!$popup) {
            return false;
          }
          if (settings.inline || settings.popup) {
            return ( module.has.popup() );
          }
          else {
            return ( $popup.closest($context).length >= 1 )
                ? true
                : false
                ;
          }
        },

        removePopup: function () {
          if (module.has.popup() && !settings.popup) {
            module.debug('Removing popup', $popup);
            $popup.remove();
            $popup = undefined;
            settings.onRemove.call($popup, element);
          }
        },

        save: {
          conditions: function () {
            module.cache = {
              title: $module.attr('title')
            };
            if (module.cache.title) {
              $module.removeAttr('title');
            }
            module.verbose('Saving original attributes', module.cache.title);
          }
        },
        restore: {
          conditions: function () {
            if (module.cache && module.cache.title) {
              $module.attr('title', module.cache.title);
              module.verbose('Restoring original attributes',
                  module.cache.title);
            }
            return true;
          }
        },
        supports: {
          svg: function () {
            return (typeof SVGGraphicsElement === undefined);
          }
        },
        animate: {
          show: function (callback) {
            callback = $.isFunction(callback) ? callback : function () {
            };
            if (settings.transition && $.fn.transition !== undefined
                && $module.transition('is supported')) {
              module.set.visible();
              $popup
              .transition({
                animation: settings.transition + ' in',
                queue: false,
                debug: settings.debug,
                verbose: settings.verbose,
                duration: settings.duration,
                onComplete: function () {
                  module.bind.close();
                  callback.call($popup, element);
                  settings.onVisible.call($popup, element);
                }
              })
              ;
            }
            else {
              module.error(error.noTransition);
            }
          },
          hide: function (callback) {
            callback = $.isFunction(callback) ? callback : function () {
            };
            module.debug('Hiding pop-up');
            if (settings.onHide.call($popup, element) === false) {
              module.debug(
                  'onHide callback returned false, cancelling popup animation');
              return;
            }
            if (settings.transition && $.fn.transition !== undefined
                && $module.transition('is supported')) {
              $popup
              .transition({
                animation: settings.transition + ' out',
                queue: false,
                duration: settings.duration,
                debug: settings.debug,
                verbose: settings.verbose,
                onComplete: function () {
                  module.reset();
                  callback.call($popup, element);
                  settings.onHidden.call($popup, element);
                }
              })
              ;
            }
            else {
              module.error(error.noTransition);
            }
          }
        },

        change: {
          content: function (html) {
            $popup.html(html);
          }
        },

        get: {
          html: function () {
            $module.removeData(metadata.html);
            return $module.data(metadata.html) || settings.html;
          },
          title: function () {
            $module.removeData(metadata.title);
            return $module.data(metadata.title) || settings.title;
          },
          content: function () {
            $module.removeData(metadata.content);
            return $module.data(metadata.content) || $module.attr('title')
                || settings.content;
          },
          variation: function () {
            $module.removeData(metadata.variation);
            return $module.data(metadata.variation) || settings.variation;
          },
          popup: function () {
            return $popup;
          },
          popupOffset: function () {
            return $popup.offset();
          },
          calculations: function () {
            var
                targetElement = $target[0],
                isWindow = ($boundary[0] == window),
                targetPosition = (settings.inline || (settings.popup
                && settings.movePopup))
                    ? $target.position()
                    : $target.offset(),
                screenPosition = (isWindow)
                    ? {top: 0, left: 0}
                    : $boundary.offset(),
                calculations = {},
                scroll = (isWindow)
                    ? {top: $window.scrollTop(), left: $window.scrollLeft()}
                    : {top: 0, left: 0},
                screen
            ;
            calculations = {
              // element which is launching popup
              target: {
                element: $target[0],
                width: $target.outerWidth(),
                height: $target.outerHeight(),
                top: targetPosition.top,
                left: targetPosition.left,
                margin: {}
              },
              // popup itself
              popup: {
                width: $popup.outerWidth(),
                height: $popup.outerHeight()
              },
              // offset container (or 3d context)
              parent: {
                width: $offsetParent.outerWidth(),
                height: $offsetParent.outerHeight()
              },
              // screen boundaries
              screen: {
                top: screenPosition.top,
                left: screenPosition.left,
                scroll: {
                  top: scroll.top,
                  left: scroll.left
                },
                width: $boundary.width(),
                height: $boundary.height()
              }
            };

            // add in container calcs if fluid
            if (settings.setFluidWidth && module.is.fluid()) {
              calculations.container = {
                width: $popup.parent().outerWidth()
              };
              calculations.popup.width = calculations.container.width;
            }

            // add in margins if inline
            calculations.target.margin.top = (settings.inline)
                ? parseInt(
                    window.getComputedStyle(targetElement).getPropertyValue(
                        'margin-top'), 10)
                : 0
            ;
            calculations.target.margin.left = (settings.inline)
                ? module.is.rtl()
                    ? parseInt(
                        window.getComputedStyle(targetElement).getPropertyValue(
                            'margin-right'), 10)
                    : parseInt(
                        window.getComputedStyle(targetElement).getPropertyValue(
                            'margin-left'), 10)
                : 0
            ;
            // calculate screen boundaries
            screen = calculations.screen;
            calculations.boundary = {
              top: screen.top + screen.scroll.top,
              bottom: screen.top + screen.scroll.top + screen.height,
              left: screen.left + screen.scroll.left,
              right: screen.left + screen.scroll.left + screen.width
            };
            return calculations;
          },
          id: function () {
            return id;
          },
          startEvent: function () {
            if (settings.on == 'hover') {
              return 'mouseenter';
            }
            else if (settings.on == 'focus') {
              return 'focus';
            }
            return false;
          },
          scrollEvent: function () {
            return 'scroll';
          },
          endEvent: function () {
            if (settings.on == 'hover') {
              return 'mouseleave';
            }
            else if (settings.on == 'focus') {
              return 'blur';
            }
            return false;
          },
          distanceFromBoundary: function (offset, calculations) {
            var
                distanceFromBoundary = {},
                popup,
                boundary
            ;
            calculations = calculations || module.get.calculations();

            // shorthand
            popup = calculations.popup;
            boundary = calculations.boundary;

            if (offset) {
              distanceFromBoundary = {
                top: (offset.top - boundary.top),
                left: (offset.left - boundary.left),
                right: (boundary.right - (offset.left + popup.width) ),
                bottom: (boundary.bottom - (offset.top + popup.height) )
              };
              module.verbose('Distance from boundaries determined', offset,
                  distanceFromBoundary);
            }
            return distanceFromBoundary;
          },
          offsetParent: function ($target) {
            var
                element = ($target !== undefined)
                    ? $target[0]
                    : $module[0],
                parentNode = element.parentNode,
                $node = $(parentNode)
            ;
            if (parentNode) {
              var
                  is2D = ($node.css('transform') === 'none'),
                  isStatic = ($node.css('position') === 'static'),
                  isHTML = $node.is('html')
              ;
              while (parentNode && !isHTML && isStatic && is2D) {
                parentNode = parentNode.parentNode;
                $node = $(parentNode);
                is2D = ($node.css('transform') === 'none');
                isStatic = ($node.css('position') === 'static');
                isHTML = $node.is('html');
              }
            }
            return ($node && $node.length > 0)
                ? $node
                : $()
                ;
          },
          positions: function () {
            return {
              'top left': false,
              'top center': false,
              'top right': false,
              'bottom left': false,
              'bottom center': false,
              'bottom right': false,
              'left center': false,
              'right center': false
            };
          },
          nextPosition: function (position) {
            var
                positions = position.split(' '),
                verticalPosition = positions[0],
                horizontalPosition = positions[1],
                opposite = {
                  top: 'bottom',
                  bottom: 'top',
                  left: 'right',
                  right: 'left'
                },
                adjacent = {
                  left: 'center',
                  center: 'right',
                  right: 'left'
                },
                backup = {
                  'top left': 'top center',
                  'top center': 'top right',
                  'top right': 'right center',
                  'right center': 'bottom right',
                  'bottom right': 'bottom center',
                  'bottom center': 'bottom left',
                  'bottom left': 'left center',
                  'left center': 'top left'
                },
                adjacentsAvailable = (verticalPosition == 'top'
                || verticalPosition == 'bottom'),
                oppositeTried = false,
                adjacentTried = false,
                nextPosition = false
            ;
            if (!triedPositions) {
              module.verbose('All available positions available');
              triedPositions = module.get.positions();
            }

            module.debug('Recording last position tried', position);
            triedPositions[position] = true;

            if (settings.prefer === 'opposite') {
              nextPosition = [opposite[verticalPosition], horizontalPosition];
              nextPosition = nextPosition.join(' ');
              oppositeTried = (triedPositions[nextPosition] === true);
              module.debug('Trying opposite strategy', nextPosition);
            }
            if ((settings.prefer === 'adjacent') && adjacentsAvailable) {
              nextPosition = [verticalPosition, adjacent[horizontalPosition]];
              nextPosition = nextPosition.join(' ');
              adjacentTried = (triedPositions[nextPosition] === true);
              module.debug('Trying adjacent strategy', nextPosition);
            }
            if (adjacentTried || oppositeTried) {
              module.debug('Using backup position', nextPosition);
              nextPosition = backup[position];
            }
            return nextPosition;
          }
        },

        set: {
          position: function (position, calculations) {

            // exit conditions
            if ($target.length === 0 || $popup.length === 0) {
              module.error(error.notFound);
              return;
            }
            var
                offset,
                distanceAway,
                target,
                popup,
                parent,
                positioning,
                popupOffset,
                distanceFromBoundary
            ;

            calculations = calculations || module.get.calculations();
            position = position || $module.data(metadata.position)
                || settings.position;

            offset = $module.data(metadata.offset) || settings.offset;
            distanceAway = settings.distanceAway;

            // shorthand
            target = calculations.target;
            popup = calculations.popup;
            parent = calculations.parent;

            if (target.width === 0 && target.height === 0 && !module.is.svg(
                    target.element)) {
              module.debug('Popup target is hidden, no action taken');
              return false;
            }

            if (settings.inline) {
              module.debug('Adding margin to calculation', target.margin);
              if (position == 'left center' || position == 'right center') {
                offset += target.margin.top;
                distanceAway += -target.margin.left;
              }
              else if (position == 'top left' || position == 'top center'
                  || position == 'top right') {
                offset += target.margin.left;
                distanceAway -= target.margin.top;
              }
              else {
                offset += target.margin.left;
                distanceAway += target.margin.top;
              }
            }

            module.debug('Determining popup position from calculations',
                position, calculations);

            if (module.is.rtl()) {
              position = position.replace(/left|right/g, function (match) {
                return (match == 'left')
                    ? 'right'
                    : 'left'
                    ;
              });
              module.debug('RTL: Popup position updated', position);
            }

            // if last attempt use specified last resort position
            if (searchDepth == settings.maxSearchDepth
                && typeof settings.lastResort === 'string') {
              position = settings.lastResort;
            }

            switch (position) {
              case 'top left':
                positioning = {
                  top: 'auto',
                  bottom: parent.height - target.top + distanceAway,
                  left: target.left + offset,
                  right: 'auto'
                };
                break;
              case 'top center':
                positioning = {
                  bottom: parent.height - target.top + distanceAway,
                  left: target.left + (target.width / 2) - (popup.width / 2)
                  + offset,
                  top: 'auto',
                  right: 'auto'
                };
                break;
              case 'top right':
                positioning = {
                  bottom: parent.height - target.top + distanceAway,
                  right: parent.width - target.left - target.width - offset,
                  top: 'auto',
                  left: 'auto'
                };
                break;
              case 'left center':
                positioning = {
                  top: target.top + (target.height / 2) - (popup.height / 2)
                  + offset,
                  right: parent.width - target.left + distanceAway,
                  left: 'auto',
                  bottom: 'auto'
                };
                break;
              case 'right center':
                positioning = {
                  top: target.top + (target.height / 2) - (popup.height / 2)
                  + offset,
                  left: target.left + target.width + distanceAway,
                  bottom: 'auto',
                  right: 'auto'
                };
                break;
              case 'bottom left':
                positioning = {
                  top: target.top + target.height + distanceAway,
                  left: target.left + offset,
                  bottom: 'auto',
                  right: 'auto'
                };
                break;
              case 'bottom center':
                positioning = {
                  top: target.top + target.height + distanceAway,
                  left: target.left + (target.width / 2) - (popup.width / 2)
                  + offset,
                  bottom: 'auto',
                  right: 'auto'
                };
                break;
              case 'bottom right':
                positioning = {
                  top: target.top + target.height + distanceAway,
                  right: parent.width - target.left - target.width - offset,
                  left: 'auto',
                  bottom: 'auto'
                };
                break;
            }
            if (positioning === undefined) {
              module.error(error.invalidPosition, position);
            }

            module.debug('Calculated popup positioning values', positioning);

            // tentatively place on stage
            $popup
            .css(positioning)
            .removeClass(className.position)
            .addClass(position)
            .addClass(className.loading)
            ;

            popupOffset = module.get.popupOffset();

            // see if any boundaries are surpassed with this tentative position
            distanceFromBoundary = module.get.distanceFromBoundary(popupOffset,
                calculations);

            if (module.is.offstage(distanceFromBoundary, position)) {
              module.debug('Position is outside viewport', position);
              if (searchDepth < settings.maxSearchDepth) {
                searchDepth++;
                position = module.get.nextPosition(position);
                module.debug('Trying new position', position);
                return ($popup)
                    ? module.set.position(position, calculations)
                    : false
                    ;
              }
              else {
                if (settings.lastResort) {
                  module.debug('No position found, showing with last position');
                }
                else {
                  module.debug('Popup could not find a position to display',
                      $popup);
                  module.error(error.cannotPlace, element);
                  module.remove.attempts();
                  module.remove.loading();
                  module.reset();
                  settings.onUnplaceable.call($popup, element);
                  return false;
                }
              }
            }
            module.debug('Position is on stage', position);
            module.remove.attempts();
            module.remove.loading();
            if (settings.setFluidWidth && module.is.fluid()) {
              module.set.fluidWidth(calculations);
            }
            return true;
          },

          fluidWidth: function (calculations) {
            calculations = calculations || module.get.calculations();
            module.debug('Automatically setting element width to parent width',
                calculations.parent.width);
            $popup.css('width', calculations.container.width);
          },

          variation: function (variation) {
            variation = variation || module.get.variation();
            if (variation && module.has.popup()) {
              module.verbose('Adding variation to popup', variation);
              $popup.addClass(variation);
            }
          },

          visible: function () {
            $module.addClass(className.visible);
          }
        },

        remove: {
          loading: function () {
            $popup.removeClass(className.loading);
          },
          variation: function (variation) {
            variation = variation || module.get.variation();
            if (variation) {
              module.verbose('Removing variation', variation);
              $popup.removeClass(variation);
            }
          },
          visible: function () {
            $module.removeClass(className.visible);
          },
          attempts: function () {
            module.verbose('Resetting all searched positions');
            searchDepth = 0;
            triedPositions = false;
          }
        },

        bind: {
          events: function () {
            module.debug('Binding popup events to module');
            if (settings.on == 'click') {
              $module
              .on('click' + eventNamespace, module.toggle)
              ;
            }
            if (settings.on == 'hover' && hasTouch) {
              $module
              .on('touchstart' + eventNamespace, module.event.touchstart)
              ;
            }
            if (module.get.startEvent()) {
              $module
              .on(module.get.startEvent() + eventNamespace, module.event.start)
              .on(module.get.endEvent() + eventNamespace, module.event.end)
              ;
            }
            if (settings.target) {
              module.debug('Target set to element', $target);
            }
            $window.on('resize' + elementNamespace, module.event.resize);
          },
          popup: function () {
            module.verbose('Allowing hover events on popup to prevent closing');
            if ($popup && module.has.popup()) {
              $popup
              .on('mouseenter' + eventNamespace, module.event.start)
              .on('mouseleave' + eventNamespace, module.event.end)
              ;
            }
          },
          close: function () {
            if (settings.hideOnScroll === true || (settings.hideOnScroll
                == 'auto' && settings.on != 'click')) {
              $scrollContext
              .one(module.get.scrollEvent() + elementNamespace,
                  module.event.hideGracefully)
              ;
            }
            if (settings.on == 'hover' && openedWithTouch) {
              module.verbose('Binding popup close event to document');
              $document
              .on('touchstart' + elementNamespace, function (event) {
                module.verbose('Touched away from popup');
                module.event.hideGracefully.call(element, event);
              })
              ;
            }
            if (settings.on == 'click' && settings.closable) {
              module.verbose('Binding popup close event to document');
              $document
              .on('click' + elementNamespace, function (event) {
                module.verbose('Clicked away from popup');
                module.event.hideGracefully.call(element, event);
              })
              ;
            }
          }
        },

        unbind: {
          events: function () {
            $window
            .off(elementNamespace)
            ;
            $module
            .off(eventNamespace)
            ;
          },
          close: function () {
            $document
            .off(elementNamespace)
            ;
            $scrollContext
            .off(elementNamespace)
            ;
          },
        },

        has: {
          popup: function () {
            return ($popup && $popup.length > 0);
          }
        },

        is: {
          offstage: function (distanceFromBoundary, position) {
            var
                offstage = []
            ;
            // return boundaries that have been surpassed
            $.each(distanceFromBoundary, function (direction, distance) {
              if (distance < -settings.jitter) {
                module.debug('Position exceeds allowable distance from edge',
                    direction, distance, position);
                offstage.push(direction);
              }
            });
            if (offstage.length > 0) {
              return true;
            }
            else {
              return false;
            }
          },
          svg: function (element) {
            return module.supports.svg() && (element
                instanceof SVGGraphicsElement);
          },
          active: function () {
            return $module.hasClass(className.active);
          },
          animating: function () {
            return ($popup !== undefined && $popup.hasClass(
                className.animating) );
          },
          fluid: function () {
            return ($popup !== undefined && $popup.hasClass(className.fluid));
          },
          visible: function () {
            return ($popup !== undefined && $popup.hasClass(className.visible));
          },
          dropdown: function () {
            return $module.hasClass(className.dropdown);
          },
          hidden: function () {
            return !module.is.visible();
          },
          rtl: function () {
            return $module.css('direction') == 'rtl';
          }
        },

        reset: function () {
          module.remove.visible();
          if (settings.preserve) {
            if ($.fn.transition !== undefined) {
              $popup
              .transition('remove transition')
              ;
            }
          }
          else {
            module.removePopup();
          }
        },

        setting: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            settings[name] = value;
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.popup.settings = {

    name: 'Popup',

    // module settings
    silent: false,
    debug: false,
    verbose: false,
    performance: true,
    namespace: 'popup',

    // whether it should use dom mutation observers
    observeChanges: true,

    // callback only when element added to dom
    onCreate: function () {
    },

    // callback before element removed from dom
    onRemove: function () {
    },

    // callback before show animation
    onShow: function () {
    },

    // callback after show animation
    onVisible: function () {
    },

    // callback before hide animation
    onHide: function () {
    },

    // callback when popup cannot be positioned in visible screen
    onUnplaceable: function () {
    },

    // callback after hide animation
    onHidden: function () {
    },

    // when to show popup
    on: 'hover',

    // element to use to determine if popup is out of boundary
    boundary: window,

    // whether to add touchstart events when using hover
    addTouchEvents: true,

    // default position relative to element
    position: 'top left',

    // name of variation to use
    variation: '',

    // whether popup should be moved to context
    movePopup: true,

    // element which popup should be relative to
    target: false,

    // jq selector or element that should be used as popup
    popup: false,

    // popup should remain inline next to activator
    inline: false,

    // popup should be removed from page on hide
    preserve: false,

    // popup should not close when being hovered on
    hoverable: false,

    // explicitly set content
    content: false,

    // explicitly set html
    html: false,

    // explicitly set title
    title: false,

    // whether automatically close on clickaway when on click
    closable: true,

    // automatically hide on scroll
    hideOnScroll: 'auto',

    // hide other popups on show
    exclusive: false,

    // context to attach popups
    context: 'body',

    // context for binding scroll events
    scrollContext: window,

    // position to prefer when calculating new position
    prefer: 'opposite',

    // specify position to appear even if it doesn't fit
    lastResort: false,

    // delay used to prevent accidental refiring of animations due to user error
    delay: {
      show: 50,
      hide: 70
    },

    // whether fluid variation should assign width explicitly
    setFluidWidth: true,

    // transition settings
    duration: 200,
    transition: 'scale',

    // distance away from activating element in px
    distanceAway: 0,

    // number of pixels an element is allowed to be "offstage" for a position to be chosen (allows for rounding)
    jitter: 2,

    // offset on aligning axis from calculated position
    offset: 0,

    // maximum times to look for a position before failing (9 positions total)
    maxSearchDepth: 15,

    error: {
      invalidPosition: 'The position you specified is not a valid position',
      cannotPlace: 'Popup does not fit within the boundaries of the viewport',
      method: 'The method you called is not defined.',
      noTransition: 'This module requires ui transitions <https://github.com/Semantic-Org/UI-Transition>',
      notFound: 'The target or popup you specified does not exist on the page'
    },

    metadata: {
      activator: 'activator',
      content: 'content',
      html: 'html',
      offset: 'offset',
      position: 'position',
      title: 'title',
      variation: 'variation'
    },

    className: {
      active: 'active',
      animating: 'animating',
      dropdown: 'dropdown',
      fluid: 'fluid',
      loading: 'loading',
      popup: 'ui popup',
      position: 'top left center bottom right',
      visible: 'visible'
    },

    selector: {
      popup: '.ui.popup'
    },

    templates: {
      escape: function (string) {
        var
            badChars = /[&<>"'`]/g,
            shouldEscape = /[&<>"'`]/,
            escape = {
              "&": "&amp;",
              "<": "&lt;",
              ">": "&gt;",
              '"': "&quot;",
              "'": "&#x27;",
              "`": "&#x60;"
            },
            escapedChar = function (chr) {
              return escape[chr];
            }
        ;
        if (shouldEscape.test(string)) {
          return string.replace(badChars, escapedChar);
        }
        return string;
      },
      popup: function (text) {
        var
            html = '',
            escape = $.fn.popup.settings.templates.escape
        ;
        if (typeof text !== undefined) {
          if (typeof text.title !== undefined && text.title) {
            text.title = escape(text.title);
            html += '<div class="header">' + text.title + '</div>';
          }
          if (typeof text.content !== undefined && text.content) {
            text.content = escape(text.content);
            html += '<div class="content">' + text.content + '</div>';
          }
        }
        return html;
      }
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Progress
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  var
      global = (typeof window != 'undefined' && window.Math == Math)
          ? window
          : (typeof self != 'undefined' && self.Math == Math)
              ? self
              : Function('return this')()
  ;

  $.fn.progress = function (parameters) {
    var
        $allModules = $(this),

        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.progress.settings, parameters)
              : $.extend({}, $.fn.progress.settings),

          className = settings.className,
          metadata = settings.metadata,
          namespace = settings.namespace,
          selector = settings.selector,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $bar = $(this).find(selector.bar),
          $progress = $(this).find(selector.progress),
          $label = $(this).find(selector.label),

          element = this,
          instance = $module.data(moduleNamespace),

          animating = false,
          transitionEnd,
          module
      ;

      module = {

        initialize: function () {
          module.debug('Initializing progress bar', settings);

          module.set.duration();
          module.set.transitionEvent();

          module.read.metadata();
          module.read.settings();

          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of progress', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },
        destroy: function () {
          module.verbose('Destroying previous progress for', $module);
          clearInterval(instance.interval);
          module.remove.state();
          $module.removeData(moduleNamespace);
          instance = undefined;
        },

        reset: function () {
          module.remove.nextValue();
          module.update.progress(0);
        },

        complete: function () {
          if (module.percent === undefined || module.percent < 100) {
            module.remove.progressPoll();
            module.set.percent(100);
          }
        },

        read: {
          metadata: function () {
            var
                data = {
                  percent: $module.data(metadata.percent),
                  total: $module.data(metadata.total),
                  value: $module.data(metadata.value)
                }
            ;
            if (data.percent) {
              module.debug('Current percent value set from metadata',
                  data.percent);
              module.set.percent(data.percent);
            }
            if (data.total) {
              module.debug('Total value set from metadata', data.total);
              module.set.total(data.total);
            }
            if (data.value) {
              module.debug('Current value set from metadata', data.value);
              module.set.value(data.value);
              module.set.progress(data.value);
            }
          },
          settings: function () {
            if (settings.total !== false) {
              module.debug('Current total set in settings', settings.total);
              module.set.total(settings.total);
            }
            if (settings.value !== false) {
              module.debug('Current value set in settings', settings.value);
              module.set.value(settings.value);
              module.set.progress(module.value);
            }
            if (settings.percent !== false) {
              module.debug('Current percent set in settings', settings.percent);
              module.set.percent(settings.percent);
            }
          }
        },

        bind: {
          transitionEnd: function (callback) {
            var
                transitionEnd = module.get.transitionEnd()
            ;
            $bar
            .one(transitionEnd + eventNamespace, function (event) {
              clearTimeout(module.failSafeTimer);
              callback.call(this, event);
            })
            ;
            module.failSafeTimer = setTimeout(function () {
              $bar.triggerHandler(transitionEnd);
            }, settings.duration + settings.failSafeDelay);
            module.verbose('Adding fail safe timer', module.timer);
          }
        },

        increment: function (incrementValue) {
          var
              maxValue,
              startValue,
              newValue
          ;
          if (module.has.total()) {
            startValue = module.get.value();
            incrementValue = incrementValue || 1;
            newValue = startValue + incrementValue;
          }
          else {
            startValue = module.get.percent();
            incrementValue = incrementValue || module.get.randomValue();

            newValue = startValue + incrementValue;
            maxValue = 100;
            module.debug('Incrementing percentage by', startValue, newValue);
          }
          newValue = module.get.normalizedValue(newValue);
          module.set.progress(newValue);
        },
        decrement: function (decrementValue) {
          var
              total = module.get.total(),
              startValue,
              newValue
          ;
          if (total) {
            startValue = module.get.value();
            decrementValue = decrementValue || 1;
            newValue = startValue - decrementValue;
            module.debug('Decrementing value by', decrementValue, startValue);
          }
          else {
            startValue = module.get.percent();
            decrementValue = decrementValue || module.get.randomValue();
            newValue = startValue - decrementValue;
            module.debug('Decrementing percentage by', decrementValue,
                startValue);
          }
          newValue = module.get.normalizedValue(newValue);
          module.set.progress(newValue);
        },

        has: {
          progressPoll: function () {
            return module.progressPoll;
          },
          total: function () {
            return (module.get.total() !== false);
          }
        },

        get: {
          text: function (templateText) {
            var
                value = module.value || 0,
                total = module.total || 0,
                percent = (animating)
                    ? module.get.displayPercent()
                    : module.percent || 0,
                left = (module.total > 0)
                    ? (total - value)
                    : (100 - percent)
            ;
            templateText = templateText || '';
            templateText = templateText
            .replace('{value}', value)
            .replace('{total}', total)
            .replace('{left}', left)
            .replace('{percent}', percent)
            ;
            module.verbose('Adding variables to progress bar text',
                templateText);
            return templateText;
          },

          normalizedValue: function (value) {
            if (value < 0) {
              module.debug('Value cannot decrement below 0');
              return 0;
            }
            if (module.has.total()) {
              if (value > module.total) {
                module.debug('Value cannot increment above total',
                    module.total);
                return module.total;
              }
            }
            else if (value > 100) {
              module.debug('Value cannot increment above 100 percent');
              return 100;
            }
            return value;
          },

          updateInterval: function () {
            if (settings.updateInterval == 'auto') {
              return settings.duration;
            }
            return settings.updateInterval;
          },

          randomValue: function () {
            module.debug('Generating random increment percentage');
            return Math.floor(
                (Math.random() * settings.random.max) + settings.random.min);
          },

          numericValue: function (value) {
            return (typeof value === 'string')
                ? (value.replace(/[^\d.]/g, '') !== '')
                    ? +(value.replace(/[^\d.]/g, ''))
                    : false
                : value
                ;
          },

          transitionEnd: function () {
            var
                element = document.createElement('element'),
                transitions = {
                  'transition': 'transitionend',
                  'OTransition': 'oTransitionEnd',
                  'MozTransition': 'transitionend',
                  'WebkitTransition': 'webkitTransitionEnd'
                },
                transition
            ;
            for (transition in transitions) {
              if (element.style[transition] !== undefined) {
                return transitions[transition];
              }
            }
          },

          // gets current displayed percentage (if animating values this is the intermediary value)
          displayPercent: function () {
            var
                barWidth = $bar.width(),
                totalWidth = $module.width(),
                minDisplay = parseInt($bar.css('min-width'), 10),
                displayPercent = (barWidth > minDisplay)
                    ? (barWidth / totalWidth * 100)
                    : module.percent
            ;
            return (settings.precision > 0)
                ? Math.round(displayPercent * (10 * settings.precision)) / (10
                * settings.precision)
                : Math.round(displayPercent)
                ;
          },

          percent: function () {
            return module.percent || 0;
          },
          value: function () {
            return module.nextValue || module.value || 0;
          },
          total: function () {
            return module.total || false;
          }
        },

        create: {
          progressPoll: function () {
            module.progressPoll = setTimeout(function () {
              module.update.toNextValue();
              module.remove.progressPoll();
            }, module.get.updateInterval());
          },
        },

        is: {
          complete: function () {
            return module.is.success() || module.is.warning()
                || module.is.error();
          },
          success: function () {
            return $module.hasClass(className.success);
          },
          warning: function () {
            return $module.hasClass(className.warning);
          },
          error: function () {
            return $module.hasClass(className.error);
          },
          active: function () {
            return $module.hasClass(className.active);
          },
          visible: function () {
            return $module.is(':visible');
          }
        },

        remove: {
          progressPoll: function () {
            module.verbose('Removing progress poll timer');
            if (module.progressPoll) {
              clearTimeout(module.progressPoll);
              delete module.progressPoll;
            }
          },
          nextValue: function () {
            module.verbose('Removing progress value stored for next update');
            delete module.nextValue;
          },
          state: function () {
            module.verbose('Removing stored state');
            delete module.total;
            delete module.percent;
            delete module.value;
          },
          active: function () {
            module.verbose('Removing active state');
            $module.removeClass(className.active);
          },
          success: function () {
            module.verbose('Removing success state');
            $module.removeClass(className.success);
          },
          warning: function () {
            module.verbose('Removing warning state');
            $module.removeClass(className.warning);
          },
          error: function () {
            module.verbose('Removing error state');
            $module.removeClass(className.error);
          }
        },

        set: {
          barWidth: function (value) {
            if (value > 100) {
              module.error(error.tooHigh, value);
            }
            else if (value < 0) {
              module.error(error.tooLow, value);
            }
            else {
              $bar
              .css('width', value + '%')
              ;
              $module
              .attr('data-percent', parseInt(value, 10))
              ;
            }
          },
          duration: function (duration) {
            duration = duration || settings.duration;
            duration = (typeof duration == 'number')
                ? duration + 'ms'
                : duration
            ;
            module.verbose('Setting progress bar transition duration',
                duration);
            $bar
            .css({
              'transition-duration': duration
            })
            ;
          },
          percent: function (percent) {
            percent = (typeof percent == 'string')
                ? +(percent.replace('%', ''))
                : percent
            ;
            // round display percentage
            percent = (settings.precision > 0)
                ? Math.round(percent * (10 * settings.precision)) / (10
                * settings.precision)
                : Math.round(percent)
            ;
            module.percent = percent;
            if (!module.has.total()) {
              module.value = (settings.precision > 0)
                  ? Math.round((percent / 100) * module.total * (10
                      * settings.precision)) / (10 * settings.precision)
                  : Math.round((percent / 100) * module.total * 10) / 10
              ;
              if (settings.limitValues) {
                module.value = (module.value > 100)
                    ? 100
                    : (module.value < 0)
                        ? 0
                        : module.value
                ;
              }
            }
            module.set.barWidth(percent);
            module.set.labelInterval();
            module.set.labels();
            settings.onChange.call(element, percent, module.value,
                module.total);
          },
          labelInterval: function () {
            var
                animationCallback = function () {
                  module.verbose(
                      'Bar finished animating, removing continuous label updates');
                  clearInterval(module.interval);
                  animating = false;
                  module.set.labels();
                }
            ;
            clearInterval(module.interval);
            module.bind.transitionEnd(animationCallback);
            animating = true;
            module.interval = setInterval(function () {
              var
                  isInDOM = $.contains(document.documentElement, element)
              ;
              if (!isInDOM) {
                clearInterval(module.interval);
                animating = false;
              }
              module.set.labels();
            }, settings.framerate);
          },
          labels: function () {
            module.verbose('Setting both bar progress and outer label text');
            module.set.barLabel();
            module.set.state();
          },
          label: function (text) {
            text = text || '';
            if (text) {
              text = module.get.text(text);
              module.verbose('Setting label to text', text);
              $label.text(text);
            }
          },
          state: function (percent) {
            percent = (percent !== undefined)
                ? percent
                : module.percent
            ;
            if (percent === 100) {
              if (settings.autoSuccess && !(module.is.warning()
                  || module.is.error() || module.is.success())) {
                module.set.success();
                module.debug('Automatically triggering success at 100%');
              }
              else {
                module.verbose('Reached 100% removing active state');
                module.remove.active();
                module.remove.progressPoll();
              }
            }
            else if (percent > 0) {
              module.verbose('Adjusting active progress bar label', percent);
              module.set.active();
            }
            else {
              module.remove.active();
              module.set.label(settings.text.active);
            }
          },
          barLabel: function (text) {
            if (text !== undefined) {
              $progress.text(module.get.text(text));
            }
            else if (settings.label == 'ratio' && module.total) {
              module.verbose('Adding ratio to bar label');
              $progress.text(module.get.text(settings.text.ratio));
            }
            else if (settings.label == 'percent') {
              module.verbose('Adding percentage to bar label');
              $progress.text(module.get.text(settings.text.percent));
            }
          },
          active: function (text) {
            text = text || settings.text.active;
            module.debug('Setting active state');
            if (settings.showActivity && !module.is.active()) {
              $module.addClass(className.active);
            }
            module.remove.warning();
            module.remove.error();
            module.remove.success();
            text = settings.onLabelUpdate('active', text, module.value,
                module.total);
            if (text) {
              module.set.label(text);
            }
            module.bind.transitionEnd(function () {
              settings.onActive.call(element, module.value, module.total);
            });
          },
          success: function (text) {
            text = text || settings.text.success || settings.text.active;
            module.debug('Setting success state');
            $module.addClass(className.success);
            module.remove.active();
            module.remove.warning();
            module.remove.error();
            module.complete();
            if (settings.text.success) {
              text = settings.onLabelUpdate('success', text, module.value,
                  module.total);
              module.set.label(text);
            }
            else {
              text = settings.onLabelUpdate('active', text, module.value,
                  module.total);
              module.set.label(text);
            }
            module.bind.transitionEnd(function () {
              settings.onSuccess.call(element, module.total);
            });
          },
          warning: function (text) {
            text = text || settings.text.warning;
            module.debug('Setting warning state');
            $module.addClass(className.warning);
            module.remove.active();
            module.remove.success();
            module.remove.error();
            module.complete();
            text = settings.onLabelUpdate('warning', text, module.value,
                module.total);
            if (text) {
              module.set.label(text);
            }
            module.bind.transitionEnd(function () {
              settings.onWarning.call(element, module.value, module.total);
            });
          },
          error: function (text) {
            text = text || settings.text.error;
            module.debug('Setting error state');
            $module.addClass(className.error);
            module.remove.active();
            module.remove.success();
            module.remove.warning();
            module.complete();
            text = settings.onLabelUpdate('error', text, module.value,
                module.total);
            if (text) {
              module.set.label(text);
            }
            module.bind.transitionEnd(function () {
              settings.onError.call(element, module.value, module.total);
            });
          },
          transitionEvent: function () {
            transitionEnd = module.get.transitionEnd();
          },
          total: function (totalValue) {
            module.total = totalValue;
          },
          value: function (value) {
            module.value = value;
          },
          progress: function (value) {
            if (!module.has.progressPoll()) {
              module.debug(
                  'First update in progress update interval, immediately updating',
                  value);
              module.update.progress(value);
              module.create.progressPoll();
            }
            else {
              module.debug(
                  'Updated within interval, setting next update to use new value',
                  value);
              module.set.nextValue(value);
            }
          },
          nextValue: function (value) {
            module.nextValue = value;
          }
        },

        update: {
          toNextValue: function () {
            var
                nextValue = module.nextValue
            ;
            if (nextValue) {
              module.debug('Update interval complete using last updated value',
                  nextValue);
              module.update.progress(nextValue);
              module.remove.nextValue();
            }
          },
          progress: function (value) {
            var
                percentComplete
            ;
            value = module.get.numericValue(value);
            if (value === false) {
              module.error(error.nonNumeric, value);
            }
            value = module.get.normalizedValue(value);
            if (module.has.total()) {
              module.set.value(value);
              percentComplete = (value / module.total) * 100;
              module.debug('Calculating percent complete from total',
                  percentComplete);
              module.set.percent(percentComplete);
            }
            else {
              percentComplete = value;
              module.debug('Setting value to exact percentage value',
                  percentComplete);
              module.set.percent(percentComplete);
            }
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.progress.settings = {

    name: 'Progress',
    namespace: 'progress',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    random: {
      min: 2,
      max: 5
    },

    duration: 300,

    updateInterval: 'auto',

    autoSuccess: true,
    showActivity: true,
    limitValues: true,

    label: 'percent',
    precision: 0,
    framerate: (1000 / 30), /// 30 fps

    percent: false,
    total: false,
    value: false,

    // delay in ms for fail safe animation callback
    failSafeDelay: 100,

    onLabelUpdate: function (state, text, value, total) {
      return text;
    },
    onChange: function (percent, value, total) {
    },
    onSuccess: function (total) {
    },
    onActive: function (value, total) {
    },
    onError: function (value, total) {
    },
    onWarning: function (value, total) {
    },

    error: {
      method: 'The method you called is not defined.',
      nonNumeric: 'Progress value is non numeric',
      tooHigh: 'Value specified is above 100%',
      tooLow: 'Value specified is below 0%'
    },

    regExp: {
      variable: /\{\$*[A-z0-9]+\}/g
    },

    metadata: {
      percent: 'percent',
      total: 'total',
      value: 'value'
    },

    selector: {
      bar: '> .bar',
      label: '> .label',
      progress: '.bar > .progress'
    },

    text: {
      active: false,
      error: false,
      success: false,
      warning: false,
      percent: '{percent}%',
      ratio: '{value} of {total}'
    },

    className: {
      active: 'active',
      error: 'error',
      success: 'success',
      warning: 'warning'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Rating
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.rating = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;
    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.rating.settings, parameters)
              : $.extend({}, $.fn.rating.settings),

          namespace = settings.namespace,
          className = settings.className,
          metadata = settings.metadata,
          selector = settings.selector,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          element = this,
          instance = $(this).data(moduleNamespace),

          $module = $(this),
          $icon = $module.find(selector.icon),

          initialLoad,
          module
      ;

      module = {

        initialize: function () {
          module.verbose('Initializing rating module', settings);

          if ($icon.length === 0) {
            module.setup.layout();
          }

          if (settings.interactive) {
            module.enable();
          }
          else {
            module.disable();
          }
          module.set.initialLoad();
          module.set.rating(module.get.initialRating());
          module.remove.initialLoad();
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Instantiating module', settings);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous instance', instance);
          module.remove.events();
          $module
          .removeData(moduleNamespace)
          ;
        },

        refresh: function () {
          $icon = $module.find(selector.icon);
        },

        setup: {
          layout: function () {
            var
                maxRating = module.get.maxRating(),
                html = $.fn.rating.settings.templates.icon(maxRating)
            ;
            module.debug('Generating icon html dynamically');
            $module
            .html(html)
            ;
            module.refresh();
          }
        },

        event: {
          mouseenter: function () {
            var
                $activeIcon = $(this)
            ;
            $activeIcon
            .nextAll()
            .removeClass(className.selected)
            ;
            $module
            .addClass(className.selected)
            ;
            $activeIcon
            .addClass(className.selected)
            .prevAll()
            .addClass(className.selected)
            ;
          },
          mouseleave: function () {
            $module
            .removeClass(className.selected)
            ;
            $icon
            .removeClass(className.selected)
            ;
          },
          click: function () {
            var
                $activeIcon = $(this),
                currentRating = module.get.rating(),
                rating = $icon.index($activeIcon) + 1,
                canClear = (settings.clearable == 'auto')
                    ? ($icon.length === 1)
                    : settings.clearable
            ;
            if (canClear && currentRating == rating) {
              module.clearRating();
            }
            else {
              module.set.rating(rating);
            }
          }
        },

        clearRating: function () {
          module.debug('Clearing current rating');
          module.set.rating(0);
        },

        bind: {
          events: function () {
            module.verbose('Binding events');
            $module
            .on('mouseenter' + eventNamespace, selector.icon,
                module.event.mouseenter)
            .on('mouseleave' + eventNamespace, selector.icon,
                module.event.mouseleave)
            .on('click' + eventNamespace, selector.icon, module.event.click)
            ;
          }
        },

        remove: {
          events: function () {
            module.verbose('Removing events');
            $module
            .off(eventNamespace)
            ;
          },
          initialLoad: function () {
            initialLoad = false;
          }
        },

        enable: function () {
          module.debug('Setting rating to interactive mode');
          module.bind.events();
          $module
          .removeClass(className.disabled)
          ;
        },

        disable: function () {
          module.debug('Setting rating to read-only mode');
          module.remove.events();
          $module
          .addClass(className.disabled)
          ;
        },

        is: {
          initialLoad: function () {
            return initialLoad;
          }
        },

        get: {
          initialRating: function () {
            if ($module.data(metadata.rating) !== undefined) {
              $module.removeData(metadata.rating);
              return $module.data(metadata.rating);
            }
            return settings.initialRating;
          },
          maxRating: function () {
            if ($module.data(metadata.maxRating) !== undefined) {
              $module.removeData(metadata.maxRating);
              return $module.data(metadata.maxRating);
            }
            return settings.maxRating;
          },
          rating: function () {
            var
                currentRating = $icon.filter('.' + className.active).length
            ;
            module.verbose('Current rating retrieved', currentRating);
            return currentRating;
          }
        },

        set: {
          rating: function (rating) {
            var
                ratingIndex = (rating - 1 >= 0)
                    ? (rating - 1)
                    : 0,
                $activeIcon = $icon.eq(ratingIndex)
            ;
            $module
            .removeClass(className.selected)
            ;
            $icon
            .removeClass(className.selected)
            .removeClass(className.active)
            ;
            if (rating > 0) {
              module.verbose('Setting current rating to', rating);
              $activeIcon
              .prevAll()
              .addBack()
              .addClass(className.active)
              ;
            }
            if (!module.is.initialLoad()) {
              settings.onRate.call(element, rating);
            }
          },
          initialLoad: function () {
            initialLoad = true;
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };
      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.rating.settings = {

    name: 'Rating',
    namespace: 'rating',

    slent: false,
    debug: false,
    verbose: false,
    performance: true,

    initialRating: 0,
    interactive: true,
    maxRating: 4,
    clearable: 'auto',

    fireOnInit: false,

    onRate: function (rating) {
    },

    error: {
      method: 'The method you called is not defined',
      noMaximum: 'No maximum rating specified. Cannot generate HTML automatically'
    },

    metadata: {
      rating: 'rating',
      maxRating: 'maxRating'
    },

    className: {
      active: 'active',
      disabled: 'disabled',
      selected: 'selected',
      loading: 'loading'
    },

    selector: {
      icon: '.icon'
    },

    templates: {
      icon: function (maxRating) {
        var
            icon = 1,
            html = ''
        ;
        while (icon <= maxRating) {
          html += '<i class="icon"></i>';
          icon++;
        }
        return html;
      }
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Search
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.search = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;
    $(this)
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.search.settings, parameters)
              : $.extend({}, $.fn.search.settings),

          className = settings.className,
          metadata = settings.metadata,
          regExp = settings.regExp,
          fields = settings.fields,
          selector = settings.selector,
          error = settings.error,
          namespace = settings.namespace,

          eventNamespace = '.' + namespace,
          moduleNamespace = namespace + '-module',

          $module = $(this),
          $prompt = $module.find(selector.prompt),
          $searchButton = $module.find(selector.searchButton),
          $results = $module.find(selector.results),
          $result = $module.find(selector.result),
          $category = $module.find(selector.category),

          element = this,
          instance = $module.data(moduleNamespace),

          disabledBubbled = false,
          resultsDismissed = false,

          module
      ;

      module = {

        initialize: function () {
          module.verbose('Initializing module');
          module.determine.searchFields();
          module.bind.events();
          module.set.type();
          module.create.results();
          module.instantiate();
        },
        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },
        destroy: function () {
          module.verbose('Destroying instance');
          $module
          .off(eventNamespace)
          .removeData(moduleNamespace)
          ;
        },

        refresh: function () {
          module.debug('Refreshing selector cache');
          $prompt = $module.find(selector.prompt);
          $searchButton = $module.find(selector.searchButton);
          $category = $module.find(selector.category);
          $results = $module.find(selector.results);
          $result = $module.find(selector.result);
        },

        refreshResults: function () {
          $results = $module.find(selector.results);
          $result = $module.find(selector.result);
        },

        bind: {
          events: function () {
            module.verbose('Binding events to search');
            if (settings.automatic) {
              $module
              .on(module.get.inputEvent() + eventNamespace, selector.prompt,
                  module.event.input)
              ;
              $prompt
              .attr('autocomplete', 'off')
              ;
            }
            $module
            // prompt
            .on('focus' + eventNamespace, selector.prompt, module.event.focus)
            .on('blur' + eventNamespace, selector.prompt, module.event.blur)
            .on('keydown' + eventNamespace, selector.prompt,
                module.handleKeyboard)
            // search button
            .on('click' + eventNamespace, selector.searchButton, module.query)
            // results
            .on('mousedown' + eventNamespace, selector.results,
                module.event.result.mousedown)
            .on('mouseup' + eventNamespace, selector.results,
                module.event.result.mouseup)
            .on('click' + eventNamespace, selector.result,
                module.event.result.click)
            ;
          }
        },

        determine: {
          searchFields: function () {
            // this makes sure $.extend does not add specified search fields to default fields
            // this is the only setting which should not extend defaults
            if (parameters && parameters.searchFields !== undefined) {
              settings.searchFields = parameters.searchFields;
            }
          }
        },

        event: {
          input: function () {
            clearTimeout(module.timer);
            module.timer = setTimeout(module.query, settings.searchDelay);
          },
          focus: function () {
            module.set.focus();
            if (settings.searchOnFocus && module.has.minimumCharacters()) {
              module.query(function () {
                if (module.can.show()) {
                  module.showResults();
                }
              });
            }
          },
          blur: function (event) {
            var
                pageLostFocus = (document.activeElement === this),
                callback = function () {
                  module.cancel.query();
                  module.remove.focus();
                  module.timer = setTimeout(module.hideResults,
                      settings.hideDelay);
                }
            ;
            if (pageLostFocus) {
              return;
            }
            resultsDismissed = false;
            if (module.resultsClicked) {
              module.debug('Determining if user action caused search to close');
              $module
              .one('click.close' + eventNamespace, selector.results,
                  function (event) {
                    if (module.is.inMessage(event) || disabledBubbled) {
                      $prompt.focus();
                      return;
                    }
                    disabledBubbled = false;
                    if (!module.is.animating() && !module.is.hidden()) {
                      callback();
                    }
                  })
              ;
            }
            else {
              module.debug(
                  'Input blurred without user action, closing results');
              callback();
            }
          },
          result: {
            mousedown: function () {
              module.resultsClicked = true;
            },
            mouseup: function () {
              module.resultsClicked = false;
            },
            click: function (event) {
              module.debug('Search result selected');
              var
                  $result = $(this),
                  $title = $result.find(selector.title).eq(0),
                  $link = $result.is('a[href]')
                      ? $result
                      : $result.find('a[href]').eq(0),
                  href = $link.attr('href') || false,
                  target = $link.attr('target') || false,
                  title = $title.html(),
                  // title is used for result lookup
                  value = ($title.length > 0)
                      ? $title.text()
                      : false,
                  results = module.get.results(),
                  result = $result.data(metadata.result) || module.get.result(
                          value, results),
                  returnedValue
              ;
              if ($.isFunction(settings.onSelect)) {
                if (settings.onSelect.call(element, result, results)
                    === false) {
                  module.debug(
                      'Custom onSelect callback cancelled default select action');
                  disabledBubbled = true;
                  return;
                }
              }
              module.hideResults();
              if (value) {
                module.set.value(value);
              }
              if (href) {
                module.verbose('Opening search link found in result', $link);
                if (target == '_blank' || event.ctrlKey) {
                  window.open(href);
                }
                else {
                  window.location.href = (href);
                }
              }
            }
          }
        },
        handleKeyboard: function (event) {
          var
              // force selector refresh
              $result = $module.find(selector.result),
              $category = $module.find(selector.category),
              $activeResult = $result.filter('.' + className.active),
              currentIndex = $result.index($activeResult),
              resultSize = $result.length,
              hasActiveResult = $activeResult.length > 0,

              keyCode = event.which,
              keys = {
                backspace: 8,
                enter: 13,
                escape: 27,
                upArrow: 38,
                downArrow: 40
              },
              newIndex
          ;
          // search shortcuts
          if (keyCode == keys.escape) {
            module.verbose('Escape key pressed, blurring search field');
            module.hideResults();
            resultsDismissed = true;
          }
          if (module.is.visible()) {
            if (keyCode == keys.enter) {
              module.verbose('Enter key pressed, selecting active result');
              if ($result.filter('.' + className.active).length > 0) {
                module.event.result.click.call(
                    $result.filter('.' + className.active), event);
                event.preventDefault();
                return false;
              }
            }
            else if (keyCode == keys.upArrow && hasActiveResult) {
              module.verbose('Up key pressed, changing active result');
              newIndex = (currentIndex - 1 < 0)
                  ? currentIndex
                  : currentIndex - 1
              ;
              $category
              .removeClass(className.active)
              ;
              $result
              .removeClass(className.active)
              .eq(newIndex)
              .addClass(className.active)
              .closest($category)
              .addClass(className.active)
              ;
              event.preventDefault();
            }
            else if (keyCode == keys.downArrow) {
              module.verbose('Down key pressed, changing active result');
              newIndex = (currentIndex + 1 >= resultSize)
                  ? currentIndex
                  : currentIndex + 1
              ;
              $category
              .removeClass(className.active)
              ;
              $result
              .removeClass(className.active)
              .eq(newIndex)
              .addClass(className.active)
              .closest($category)
              .addClass(className.active)
              ;
              event.preventDefault();
            }
          }
          else {
            // query shortcuts
            if (keyCode == keys.enter) {
              module.verbose('Enter key pressed, executing query');
              module.query();
              module.set.buttonPressed();
              $prompt.one('keyup', module.remove.buttonFocus);
            }
          }
        },

        setup: {
          api: function (searchTerm, callback) {
            var
                apiSettings = {
                  debug: settings.debug,
                  on: false,
                  cache: true,
                  action: 'search',
                  urlData: {
                    query: searchTerm
                  },
                  onSuccess: function (response) {
                    module.parse.response.call(element, response, searchTerm);
                    callback();
                  },
                  onFailure: function () {
                    module.displayMessage(error.serverError);
                    callback();
                  },
                  onAbort: function (response) {
                  },
                  onError: module.error
                },
                searchHTML
            ;
            $.extend(true, apiSettings, settings.apiSettings);
            module.verbose('Setting up API request', apiSettings);
            $module.api(apiSettings);
          }
        },

        can: {
          useAPI: function () {
            return $.fn.api !== undefined;
          },
          show: function () {
            return module.is.focused() && !module.is.visible()
                && !module.is.empty();
          },
          transition: function () {
            return settings.transition && $.fn.transition !== undefined
                && $module.transition('is supported');
          }
        },

        is: {
          animating: function () {
            return $results.hasClass(className.animating);
          },
          hidden: function () {
            return $results.hasClass(className.hidden);
          },
          inMessage: function (event) {
            if (!event.target) {
              return;
            }
            var
                $target = $(event.target),
                isInDOM = $.contains(document.documentElement, event.target)
            ;
            return (isInDOM && $target.closest(selector.message).length > 0);
          },
          empty: function () {
            return ($results.html() === '');
          },
          visible: function () {
            return ($results.filter(':visible').length > 0);
          },
          focused: function () {
            return ($prompt.filter(':focus').length > 0);
          }
        },

        get: {
          inputEvent: function () {
            var
                prompt = $prompt[0],
                inputEvent = (prompt !== undefined && prompt.oninput
                !== undefined)
                    ? 'input'
                    : (prompt !== undefined && prompt.onpropertychange
                    !== undefined)
                        ? 'propertychange'
                        : 'keyup'
            ;
            return inputEvent;
          },
          value: function () {
            return $prompt.val();
          },
          results: function () {
            var
                results = $module.data(metadata.results)
            ;
            return results;
          },
          result: function (value, results) {
            var
                lookupFields = ['title', 'id'],
                result = false
            ;
            value = (value !== undefined)
                ? value
                : module.get.value()
            ;
            results = (results !== undefined)
                ? results
                : module.get.results()
            ;
            if (settings.type === 'category') {
              module.debug('Finding result that matches', value);
              $.each(results, function (index, category) {
                if ($.isArray(category.results)) {
                  result = module.search.object(value, category.results,
                      lookupFields)[0];
                  // don't continue searching if a result is found
                  if (result) {
                    return false;
                  }
                }
              });
            }
            else {
              module.debug('Finding result in results object', value);
              result = module.search.object(value, results, lookupFields)[0];
            }
            return result || false;
          },
        },

        select: {
          firstResult: function () {
            module.verbose('Selecting first result');
            $result.first().addClass(className.active);
          }
        },

        set: {
          focus: function () {
            $module.addClass(className.focus);
          },
          loading: function () {
            $module.addClass(className.loading);
          },
          value: function (value) {
            module.verbose('Setting search input value', value);
            $prompt
            .val(value)
            ;
          },
          type: function (type) {
            type = type || settings.type;
            if (settings.type == 'category') {
              $module.addClass(settings.type);
            }
          },
          buttonPressed: function () {
            $searchButton.addClass(className.pressed);
          }
        },

        remove: {
          loading: function () {
            $module.removeClass(className.loading);
          },
          focus: function () {
            $module.removeClass(className.focus);
          },
          buttonPressed: function () {
            $searchButton.removeClass(className.pressed);
          }
        },

        query: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          var
              searchTerm = module.get.value(),
              cache = module.read.cache(searchTerm)
          ;
          callback = callback || function () {
              };
          if (module.has.minimumCharacters()) {
            if (cache) {
              module.debug('Reading result from cache', searchTerm);
              module.save.results(cache.results);
              module.addResults(cache.html);
              module.inject.id(cache.results);
              callback();
            }
            else {
              module.debug('Querying for', searchTerm);
              if ($.isPlainObject(settings.source) || $.isArray(
                      settings.source)) {
                module.search.local(searchTerm);
                callback();
              }
              else if (module.can.useAPI()) {
                module.search.remote(searchTerm, callback);
              }
              else {
                module.error(error.source);
                callback();
              }
            }
            settings.onSearchQuery.call(element, searchTerm);
          }
          else {
            module.hideResults();
          }
        },

        search: {
          local: function (searchTerm) {
            var
                results = module.search.object(searchTerm, settings.content),
                searchHTML
            ;
            module.set.loading();
            module.save.results(results);
            module.debug('Returned local search results', results);

            searchHTML = module.generateResults({
              results: results
            });
            module.remove.loading();
            module.addResults(searchHTML);
            module.inject.id(results);
            module.write.cache(searchTerm, {
              html: searchHTML,
              results: results
            });
          },
          remote: function (searchTerm, callback) {
            callback = $.isFunction(callback)
                ? callback
                : function () {
                }
            ;
            if ($module.api('is loading')) {
              $module.api('abort');
            }
            module.setup.api(searchTerm, callback);
            $module
            .api('query')
            ;
          },
          object: function (searchTerm, source, searchFields) {
            var
                results = [],
                fuzzyResults = [],
                searchExp = searchTerm.toString().replace(regExp.escape,
                    '\\$&'),
                matchRegExp = new RegExp(regExp.beginsWith + searchExp, 'i'),

                // avoid duplicates when pushing results
                addResult = function (array, result) {
                  var
                      notResult = ($.inArray(result, results) == -1),
                      notFuzzyResult = ($.inArray(result, fuzzyResults) == -1)
                  ;
                  if (notResult && notFuzzyResult) {
                    array.push(result);
                  }
                }
            ;
            source = source || settings.source;
            searchFields = (searchFields !== undefined)
                ? searchFields
                : settings.searchFields
            ;

            // search fields should be array to loop correctly
            if (!$.isArray(searchFields)) {
              searchFields = [searchFields];
            }

            // exit conditions if no source
            if (source === undefined || source === false) {
              module.error(error.source);
              return [];
            }

            // iterate through search fields looking for matches
            $.each(searchFields, function (index, field) {
              $.each(source, function (label, content) {
                var
                    fieldExists = (typeof content[field] == 'string')
                ;
                if (fieldExists) {
                  if (content[field].search(matchRegExp) !== -1) {
                    // content starts with value (first in results)
                    addResult(results, content);
                  }
                  else if (settings.searchFullText && module.fuzzySearch(
                          searchTerm, content[field])) {
                    // content fuzzy matches (last in results)
                    addResult(fuzzyResults, content);
                  }
                }
              });
            });
            return $.merge(results, fuzzyResults);
          }
        },

        fuzzySearch: function (query, term) {
          var
              termLength = term.length,
              queryLength = query.length
          ;
          if (typeof query !== 'string') {
            return false;
          }
          query = query.toLowerCase();
          term = term.toLowerCase();
          if (queryLength > termLength) {
            return false;
          }
          if (queryLength === termLength) {
            return (query === term);
          }
          search: for (var characterIndex = 0, nextCharacterIndex = 0;
              characterIndex < queryLength; characterIndex++) {
            var
                queryCharacter = query.charCodeAt(characterIndex)
            ;
            while (nextCharacterIndex < termLength) {
              if (term.charCodeAt(nextCharacterIndex++) === queryCharacter) {
                continue search;
              }
            }
            return false;
          }
          return true;
        },

        parse: {
          response: function (response, searchTerm) {
            var
                searchHTML = module.generateResults(response)
            ;
            module.verbose('Parsing server response', response);
            if (response !== undefined) {
              if (searchTerm !== undefined && response[fields.results]
                  !== undefined) {
                module.addResults(searchHTML);
                module.inject.id(response[fields.results]);
                module.write.cache(searchTerm, {
                  html: searchHTML,
                  results: response[fields.results]
                });
                module.save.results(response[fields.results]);
              }
            }
          }
        },

        cancel: {
          query: function () {
            if (module.can.useAPI()) {
              $module.api('abort');
            }
          }
        },

        has: {
          minimumCharacters: function () {
            var
                searchTerm = module.get.value(),
                numCharacters = searchTerm.length
            ;
            return (numCharacters >= settings.minCharacters);
          },
          results: function () {
            if ($results.length === 0) {
              return false;
            }
            var
                html = $results.html()
            ;
            return html != '';
          }
        },

        clear: {
          cache: function (value) {
            var
                cache = $module.data(metadata.cache)
            ;
            if (!value) {
              module.debug('Clearing cache', value);
              $module.removeData(metadata.cache);
            }
            else if (value && cache && cache[value]) {
              module.debug('Removing value from cache', value);
              delete cache[value];
              $module.data(metadata.cache, cache);
            }
          }
        },

        read: {
          cache: function (name) {
            var
                cache = $module.data(metadata.cache)
            ;
            if (settings.cache) {
              module.verbose('Checking cache for generated html for query',
                  name);
              return (typeof cache == 'object') && (cache[name] !== undefined)
                  ? cache[name]
                  : false
                  ;
            }
            return false;
          }
        },

        create: {
          id: function (resultIndex, categoryIndex) {
            var
                resultID = (resultIndex + 1), // not zero indexed
                categoryID = (categoryIndex + 1),
                firstCharCode,
                letterID,
                id
            ;
            if (categoryIndex !== undefined) {
              // start char code for "A"
              letterID = String.fromCharCode(97 + categoryIndex);
              id = letterID + resultID;
              module.verbose('Creating category result id', id);
            }
            else {
              id = resultID;
              module.verbose('Creating result id', id);
            }
            return id;
          },
          results: function () {
            if ($results.length === 0) {
              $results = $('<div />')
              .addClass(className.results)
              .appendTo($module)
              ;
            }
          }
        },

        inject: {
          result: function (result, resultIndex, categoryIndex) {
            module.verbose('Injecting result into results');
            var
                $selectedResult = (categoryIndex !== undefined)
                    ? $results
                    .children().eq(categoryIndex)
                    .children(selector.result).eq(resultIndex)
                    : $results
                    .children(selector.result).eq(resultIndex)
            ;
            module.verbose('Injecting results metadata', $selectedResult);
            $selectedResult
            .data(metadata.result, result)
            ;
          },
          id: function (results) {
            module.debug('Injecting unique ids into results');
            var
                // since results may be object, we must use counters
                categoryIndex = 0,
                resultIndex = 0
            ;
            if (settings.type === 'category') {
              // iterate through each category result
              $.each(results, function (index, category) {
                resultIndex = 0;
                $.each(category.results, function (index, value) {
                  var
                      result = category.results[index]
                  ;
                  if (result.id === undefined) {
                    result.id = module.create.id(resultIndex, categoryIndex);
                  }
                  module.inject.result(result, resultIndex, categoryIndex);
                  resultIndex++;
                });
                categoryIndex++;
              });
            }
            else {
              // top level
              $.each(results, function (index, value) {
                var
                    result = results[index]
                ;
                if (result.id === undefined) {
                  result.id = module.create.id(resultIndex);
                }
                module.inject.result(result, resultIndex);
                resultIndex++;
              });
            }
            return results;
          }
        },

        save: {
          results: function (results) {
            module.verbose('Saving current search results to metadata',
                results);
            $module.data(metadata.results, results);
          }
        },

        write: {
          cache: function (name, value) {
            var
                cache = ($module.data(metadata.cache) !== undefined)
                    ? $module.data(metadata.cache)
                    : {}
            ;
            if (settings.cache) {
              module.verbose('Writing generated html to cache', name, value);
              cache[name] = value;
              $module
              .data(metadata.cache, cache)
              ;
            }
          }
        },

        addResults: function (html) {
          if ($.isFunction(settings.onResultsAdd)) {
            if (settings.onResultsAdd.call($results, html) === false) {
              module.debug('onResultsAdd callback cancelled default action');
              return false;
            }
          }
          if (html) {
            $results
            .html(html)
            ;
            module.refreshResults();
            if (settings.selectFirstResult) {
              module.select.firstResult();
            }
            module.showResults();
          }
          else {
            module.hideResults(function () {
              $results.empty();
            });
          }
        },

        showResults: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (resultsDismissed) {
            return;
          }
          if (!module.is.visible() && module.has.results()) {
            if (module.can.transition()) {
              module.debug('Showing results with css animations');
              $results
              .transition({
                animation: settings.transition + ' in',
                debug: settings.debug,
                verbose: settings.verbose,
                duration: settings.duration,
                onComplete: function () {
                  callback();
                },
                queue: true
              })
              ;
            }
            else {
              module.debug('Showing results with javascript');
              $results
              .stop()
              .fadeIn(settings.duration, settings.easing)
              ;
            }
            settings.onResultsOpen.call($results);
          }
        },
        hideResults: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (module.is.visible()) {
            if (module.can.transition()) {
              module.debug('Hiding results with css animations');
              $results
              .transition({
                animation: settings.transition + ' out',
                debug: settings.debug,
                verbose: settings.verbose,
                duration: settings.duration,
                onComplete: function () {
                  callback();
                },
                queue: true
              })
              ;
            }
            else {
              module.debug('Hiding results with javascript');
              $results
              .stop()
              .fadeOut(settings.duration, settings.easing)
              ;
            }
            settings.onResultsClose.call($results);
          }
        },

        generateResults: function (response) {
          module.debug('Generating html from response', response);
          var
              template = settings.templates[settings.type],
              isProperObject = ($.isPlainObject(response[fields.results])
              && !$.isEmptyObject(response[fields.results])),
              isProperArray = ($.isArray(response[fields.results])
              && response[fields.results].length > 0),
              html = ''
          ;
          if (isProperObject || isProperArray) {
            if (settings.maxResults > 0) {
              if (isProperObject) {
                if (settings.type == 'standard') {
                  module.error(error.maxResults);
                }
              }
              else {
                response[fields.results] = response[fields.results].slice(0,
                    settings.maxResults);
              }
            }
            if ($.isFunction(template)) {
              html = template(response, fields);
            }
            else {
              module.error(error.noTemplate, false);
            }
          }
          else if (settings.showNoResults) {
            html = module.displayMessage(error.noResults, 'empty');
          }
          settings.onResults.call(element, response);
          return html;
        },

        displayMessage: function (text, type) {
          type = type || 'standard';
          module.debug('Displaying message', text, type);
          module.addResults(settings.templates.message(text, type));
          return settings.templates.message(text, type);
        },

        setting: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            settings[name] = value;
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };
      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }

    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.search.settings = {

    name: 'Search',
    namespace: 'search',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    // template to use (specified in settings.templates)
    type: 'standard',

    // minimum characters required to search
    minCharacters: 1,

    // whether to select first result after searching automatically
    selectFirstResult: false,

    // API config
    apiSettings: false,

    // object to search
    source: false,

    // Whether search should query current term on focus
    searchOnFocus: true,

    // fields to search
    searchFields: [
      'title',
      'description'
    ],

    // field to display in standard results template
    displayField: '',

    // whether to include fuzzy results in local search
    searchFullText: true,

    // whether to add events to prompt automatically
    automatic: true,

    // delay before hiding menu after blur
    hideDelay: 0,

    // delay before searching
    searchDelay: 200,

    // maximum results returned from local
    maxResults: 7,

    // whether to store lookups in local cache
    cache: true,

    // whether no results errors should be shown
    showNoResults: true,

    // transition settings
    transition: 'scale',
    duration: 200,
    easing: 'easeOutExpo',

    // callbacks
    onSelect: false,
    onResultsAdd: false,

    onSearchQuery: function (query) {
    },
    onResults: function (response) {
    },

    onResultsOpen: function () {
    },
    onResultsClose: function () {
    },

    className: {
      animating: 'animating',
      active: 'active',
      empty: 'empty',
      focus: 'focus',
      hidden: 'hidden',
      loading: 'loading',
      results: 'results',
      pressed: 'down'
    },

    error: {
      source: 'Cannot search. No source used, and Semantic API module was not included',
      noResults: 'Your search returned no results',
      logging: 'Error in debug logging, exiting.',
      noEndpoint: 'No search endpoint was specified',
      noTemplate: 'A valid template name was not specified.',
      serverError: 'There was an issue querying the server.',
      maxResults: 'Results must be an array to use maxResults setting',
      method: 'The method you called is not defined.'
    },

    metadata: {
      cache: 'cache',
      results: 'results',
      result: 'result'
    },

    regExp: {
      escape: /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,
      beginsWith: '(?:\s|^)'
    },

    // maps api response attributes to internal representation
    fields: {
      categories: 'results',     // array of categories (category view)
      categoryName: 'name',        // name of category (category view)
      categoryResults: 'results',     // array of results (category view)
      description: 'description', // result description
      image: 'image',       // result image
      price: 'price',       // result price
      results: 'results',     // array of results (standard)
      title: 'title',       // result title
      url: 'url',         // result url
      action: 'action',      // "view more" object name
      actionText: 'text',        // "view more" text
      actionURL: 'url'          // "view more" url
    },

    selector: {
      prompt: '.prompt',
      searchButton: '.search.button',
      results: '.results',
      message: '.results > .message',
      category: '.category',
      result: '.result',
      title: '.title, .name'
    },

    templates: {
      escape: function (string) {
        var
            badChars = /[&<>"'`]/g,
            shouldEscape = /[&<>"'`]/,
            escape = {
              "&": "&amp;",
              "<": "&lt;",
              ">": "&gt;",
              '"': "&quot;",
              "'": "&#x27;",
              "`": "&#x60;"
            },
            escapedChar = function (chr) {
              return escape[chr];
            }
        ;
        if (shouldEscape.test(string)) {
          return string.replace(badChars, escapedChar);
        }
        return string;
      },
      message: function (message, type) {
        var
            html = ''
        ;
        if (message !== undefined && type !== undefined) {
          html += ''
              + '<div class="message ' + type + '">'
          ;
          // message type
          if (type == 'empty') {
            html += ''
                + '<div class="header">No Results</div class="header">'
                + '<div class="description">' + message
                + '</div class="description">'
            ;
          }
          else {
            html += ' <div class="description">' + message + '</div>';
          }
          html += '</div>';
        }
        return html;
      },
      category: function (response, fields) {
        var
            html = '',
            escape = $.fn.search.settings.templates.escape
        ;
        if (response[fields.categoryResults] !== undefined) {

          // each category
          $.each(response[fields.categoryResults], function (index, category) {
            if (category[fields.results] !== undefined
                && category.results.length > 0) {

              html += '<div class="category">';

              if (category[fields.categoryName] !== undefined) {
                html += '<div class="name">' + category[fields.categoryName]
                    + '</div>';
              }

              // each item inside category
              $.each(category.results, function (index, result) {
                if (result[fields.url]) {
                  html += '<a class="result" href="' + result[fields.url]
                      + '">';
                }
                else {
                  html += '<a class="result">';
                }
                if (result[fields.image] !== undefined) {
                  html += ''
                      + '<div class="image">'
                      + ' <img src="' + result[fields.image] + '">'
                      + '</div>'
                  ;
                }
                html += '<div class="content">';
                if (result[fields.price] !== undefined) {
                  html += '<div class="price">' + result[fields.price]
                      + '</div>';
                }
                if (result[fields.title] !== undefined) {
                  html += '<div class="title">' + result[fields.title]
                      + '</div>';
                }
                if (result[fields.description] !== undefined) {
                  html += '<div class="description">'
                      + result[fields.description] + '</div>';
                }
                html += ''
                    + '</div>'
                ;
                html += '</a>';
              });
              html += ''
                  + '</div>'
              ;
            }
          });
          if (response[fields.action]) {
            html += ''
                + '<a href="' + response[fields.action][fields.actionURL]
                + '" class="action">'
                + response[fields.action][fields.actionText]
                + '</a>';
          }
          return html;
        }
        return false;
      },
      standard: function (response, fields) {
        var
            html = ''
        ;
        if (response[fields.results] !== undefined) {

          // each result
          $.each(response[fields.results], function (index, result) {
            if (result[fields.url]) {
              html += '<a class="result" href="' + result[fields.url] + '">';
            }
            else {
              html += '<a class="result">';
            }
            if (result[fields.image] !== undefined) {
              html += ''
                  + '<div class="image">'
                  + ' <img src="' + result[fields.image] + '">'
                  + '</div>'
              ;
            }
            html += '<div class="content">';
            if (result[fields.price] !== undefined) {
              html += '<div class="price">' + result[fields.price] + '</div>';
            }
            if (result[fields.title] !== undefined) {
              html += '<div class="title">' + result[fields.title] + '</div>';
            }
            if (result[fields.description] !== undefined) {
              html += '<div class="description">' + result[fields.description]
                  + '</div>';
            }
            html += ''
                + '</div>'
            ;
            html += '</a>';
          });

          if (response[fields.action]) {
            html += ''
                + '<a href="' + response[fields.action][fields.actionURL]
                + '" class="action">'
                + response[fields.action][fields.actionText]
                + '</a>';
          }
          return html;
        }
        return false;
      }
    }
  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Shape
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.shape = function (parameters) {
    var
        $allModules = $(this),
        $body = $('body'),

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) {
              setTimeout(callback, 0);
            },

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          moduleSelector = $allModules.selector || '',
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.shape.settings, parameters)
              : $.extend({}, $.fn.shape.settings),

          // internal aliases
          namespace = settings.namespace,
          selector = settings.selector,
          error = settings.error,
          className = settings.className,

          // define namespaces for modules
          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          // selector cache
          $module = $(this),
          $sides = $module.find(selector.sides),
          $side = $module.find(selector.side),

          // private variables
          nextIndex = false,
          $activeSide,
          $nextSide,

          // standard module
          element = this,
          instance = $module.data(moduleNamespace),
          module
      ;

      module = {

        initialize: function () {
          module.verbose('Initializing module for', element);
          module.set.defaultSide();
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, instance)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous module for', element);
          $module
          .removeData(moduleNamespace)
          .off(eventNamespace)
          ;
        },

        refresh: function () {
          module.verbose('Refreshing selector cache for', element);
          $module = $(element);
          $sides = $(this).find(selector.shape);
          $side = $(this).find(selector.side);
        },

        repaint: function () {
          module.verbose('Forcing repaint event');
          var
              shape = $sides[0] || document.createElement('div'),
              fakeAssignment = shape.offsetWidth
          ;
        },

        animate: function (propertyObject, callback) {
          module.verbose('Animating box with properties', propertyObject);
          callback = callback || function (event) {
                module.verbose('Executing animation callback');
                if (event !== undefined) {
                  event.stopPropagation();
                }
                module.reset();
                module.set.active();
              };
          settings.beforeChange.call($nextSide[0]);
          if (module.get.transitionEvent()) {
            module.verbose('Starting CSS animation');
            $module
            .addClass(className.animating)
            ;
            $sides
            .css(propertyObject)
            .one(module.get.transitionEvent(), callback)
            ;
            module.set.duration(settings.duration);
            requestAnimationFrame(function () {
              $module
              .addClass(className.animating)
              ;
              $activeSide
              .addClass(className.hidden)
              ;
            });
          }
          else {
            callback();
          }
        },

        queue: function (method) {
          module.debug('Queueing animation of', method);
          $sides
          .one(module.get.transitionEvent(), function () {
            module.debug('Executing queued animation');
            setTimeout(function () {
              $module.shape(method);
            }, 0);
          })
          ;
        },

        reset: function () {
          module.verbose('Animating states reset');
          $module
          .removeClass(className.animating)
          .attr('style', '')
          .removeAttr('style')
          ;
          // removeAttr style does not consistently work in safari
          $sides
          .attr('style', '')
          .removeAttr('style')
          ;
          $side
          .attr('style', '')
          .removeAttr('style')
          .removeClass(className.hidden)
          ;
          $nextSide
          .removeClass(className.animating)
          .attr('style', '')
          .removeAttr('style')
          ;
        },

        is: {
          complete: function () {
            return ($side.filter('.' + className.active)[0] == $nextSide[0]);
          },
          animating: function () {
            return $module.hasClass(className.animating);
          }
        },

        set: {

          defaultSide: function () {
            $activeSide = $module.find('.' + settings.className.active);
            $nextSide = ( $activeSide.next(selector.side).length > 0 )
                ? $activeSide.next(selector.side)
                : $module.find(selector.side).first()
            ;
            nextIndex = false;
            module.verbose('Active side set to', $activeSide);
            module.verbose('Next side set to', $nextSide);
          },

          duration: function (duration) {
            duration = duration || settings.duration;
            duration = (typeof duration == 'number')
                ? duration + 'ms'
                : duration
            ;
            module.verbose('Setting animation duration', duration);
            if (settings.duration || settings.duration === 0) {
              $sides.add($side)
              .css({
                '-webkit-transition-duration': duration,
                '-moz-transition-duration': duration,
                '-ms-transition-duration': duration,
                '-o-transition-duration': duration,
                'transition-duration': duration
              })
              ;
            }
          },

          currentStageSize: function () {
            var
                $activeSide = $module.find('.' + settings.className.active),
                width = $activeSide.outerWidth(true),
                height = $activeSide.outerHeight(true)
            ;
            $module
            .css({
              width: width,
              height: height
            })
            ;
          },

          stageSize: function () {
            var
                $clone = $module.clone().addClass(className.loading),
                $activeSide = $clone.find('.' + settings.className.active),
                $nextSide = (nextIndex)
                    ? $clone.find(selector.side).eq(nextIndex)
                    : ( $activeSide.next(selector.side).length > 0 )
                        ? $activeSide.next(selector.side)
                        : $clone.find(selector.side).first(),
                newWidth = (settings.width == 'next')
                    ? $nextSide.outerWidth(true)
                    : (settings.width == 'initial')
                        ? $module.width()
                        : settings.width,
                newHeight = (settings.height == 'next')
                    ? $nextSide.outerHeight(true)
                    : (settings.height == 'initial')
                        ? $module.height()
                        : settings.height
            ;
            $activeSide.removeClass(className.active);
            $nextSide.addClass(className.active);
            $clone.insertAfter($module);
            $clone.remove();
            if (settings.width != 'auto') {
              $module.css('width', newWidth + settings.jitter);
              module.verbose('Specifying width during animation', newWidth);
            }
            if (settings.height != 'auto') {
              $module.css('height', newHeight + settings.jitter);
              module.verbose('Specifying height during animation', newHeight);
            }
          },

          nextSide: function (selector) {
            nextIndex = selector;
            $nextSide = $side.filter(selector);
            nextIndex = $side.index($nextSide);
            if ($nextSide.length === 0) {
              module.set.defaultSide();
              module.error(error.side);
            }
            module.verbose('Next side manually set to', $nextSide);
          },

          active: function () {
            module.verbose('Setting new side to active', $nextSide);
            $side
            .removeClass(className.active)
            ;
            $nextSide
            .addClass(className.active)
            ;
            settings.onChange.call($nextSide[0]);
            module.set.defaultSide();
          }
        },

        flip: {

          up: function () {
            if (module.is.complete() && !module.is.animating()
                && !settings.allowRepeats) {
              module.debug('Side already visible', $nextSide);
              return;
            }
            if (!module.is.animating()) {
              module.debug('Flipping up', $nextSide);
              var
                  transform = module.get.transform.up()
              ;
              module.set.stageSize();
              module.stage.above();
              module.animate(transform);
            }
            else {
              module.queue('flip up');
            }
          },

          down: function () {
            if (module.is.complete() && !module.is.animating()
                && !settings.allowRepeats) {
              module.debug('Side already visible', $nextSide);
              return;
            }
            if (!module.is.animating()) {
              module.debug('Flipping down', $nextSide);
              var
                  transform = module.get.transform.down()
              ;
              module.set.stageSize();
              module.stage.below();
              module.animate(transform);
            }
            else {
              module.queue('flip down');
            }
          },

          left: function () {
            if (module.is.complete() && !module.is.animating()
                && !settings.allowRepeats) {
              module.debug('Side already visible', $nextSide);
              return;
            }
            if (!module.is.animating()) {
              module.debug('Flipping left', $nextSide);
              var
                  transform = module.get.transform.left()
              ;
              module.set.stageSize();
              module.stage.left();
              module.animate(transform);
            }
            else {
              module.queue('flip left');
            }
          },

          right: function () {
            if (module.is.complete() && !module.is.animating()
                && !settings.allowRepeats) {
              module.debug('Side already visible', $nextSide);
              return;
            }
            if (!module.is.animating()) {
              module.debug('Flipping right', $nextSide);
              var
                  transform = module.get.transform.right()
              ;
              module.set.stageSize();
              module.stage.right();
              module.animate(transform);
            }
            else {
              module.queue('flip right');
            }
          },

          over: function () {
            if (module.is.complete() && !module.is.animating()
                && !settings.allowRepeats) {
              module.debug('Side already visible', $nextSide);
              return;
            }
            if (!module.is.animating()) {
              module.debug('Flipping over', $nextSide);
              module.set.stageSize();
              module.stage.behind();
              module.animate(module.get.transform.over());
            }
            else {
              module.queue('flip over');
            }
          },

          back: function () {
            if (module.is.complete() && !module.is.animating()
                && !settings.allowRepeats) {
              module.debug('Side already visible', $nextSide);
              return;
            }
            if (!module.is.animating()) {
              module.debug('Flipping back', $nextSide);
              module.set.stageSize();
              module.stage.behind();
              module.animate(module.get.transform.back());
            }
            else {
              module.queue('flip back');
            }
          }

        },

        get: {

          transform: {
            up: function () {
              var
                  translate = {
                    y: -(($activeSide.outerHeight(true) - $nextSide.outerHeight(
                        true)) / 2),
                    z: -($activeSide.outerHeight(true) / 2)
                  }
              ;
              return {
                transform: 'translateY(' + translate.y + 'px) translateZ('
                + translate.z + 'px) rotateX(-90deg)'
              };
            },

            down: function () {
              var
                  translate = {
                    y: -(($activeSide.outerHeight(true) - $nextSide.outerHeight(
                        true)) / 2),
                    z: -($activeSide.outerHeight(true) / 2)
                  }
              ;
              return {
                transform: 'translateY(' + translate.y + 'px) translateZ('
                + translate.z + 'px) rotateX(90deg)'
              };
            },

            left: function () {
              var
                  translate = {
                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(
                        true)) / 2),
                    z: -($activeSide.outerWidth(true) / 2)
                  }
              ;
              return {
                transform: 'translateX(' + translate.x + 'px) translateZ('
                + translate.z + 'px) rotateY(90deg)'
              };
            },

            right: function () {
              var
                  translate = {
                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(
                        true)) / 2),
                    z: -($activeSide.outerWidth(true) / 2)
                  }
              ;
              return {
                transform: 'translateX(' + translate.x + 'px) translateZ('
                + translate.z + 'px) rotateY(-90deg)'
              };
            },

            over: function () {
              var
                  translate = {
                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(
                        true)) / 2)
                  }
              ;
              return {
                transform: 'translateX(' + translate.x + 'px) rotateY(180deg)'
              };
            },

            back: function () {
              var
                  translate = {
                    x: -(($activeSide.outerWidth(true) - $nextSide.outerWidth(
                        true)) / 2)
                  }
              ;
              return {
                transform: 'translateX(' + translate.x + 'px) rotateY(-180deg)'
              };
            }
          },

          transitionEvent: function () {
            var
                element = document.createElement('element'),
                transitions = {
                  'transition': 'transitionend',
                  'OTransition': 'oTransitionEnd',
                  'MozTransition': 'transitionend',
                  'WebkitTransition': 'webkitTransitionEnd'
                },
                transition
            ;
            for (transition in transitions) {
              if (element.style[transition] !== undefined) {
                return transitions[transition];
              }
            }
          },

          nextSide: function () {
            return ( $activeSide.next(selector.side).length > 0 )
                ? $activeSide.next(selector.side)
                : $module.find(selector.side).first()
                ;
          }

        },

        stage: {

          above: function () {
            var
                box = {
                  origin: (($activeSide.outerHeight(true)
                  - $nextSide.outerHeight(true)) / 2),
                  depth: {
                    active: ($nextSide.outerHeight(true) / 2),
                    next: ($activeSide.outerHeight(true) / 2)
                  }
                }
            ;
            module.verbose('Setting the initial animation position as above',
                $nextSide, box);
            $sides
            .css({
              'transform': 'translateZ(-' + box.depth.active + 'px)'
            })
            ;
            $activeSide
            .css({
              'transform': 'rotateY(0deg) translateZ(' + box.depth.active
              + 'px)'
            })
            ;
            $nextSide
            .addClass(className.animating)
            .css({
              'top': box.origin + 'px',
              'transform': 'rotateX(90deg) translateZ(' + box.depth.next + 'px)'
            })
            ;
          },

          below: function () {
            var
                box = {
                  origin: (($activeSide.outerHeight(true)
                  - $nextSide.outerHeight(true)) / 2),
                  depth: {
                    active: ($nextSide.outerHeight(true) / 2),
                    next: ($activeSide.outerHeight(true) / 2)
                  }
                }
            ;
            module.verbose('Setting the initial animation position as below',
                $nextSide, box);
            $sides
            .css({
              'transform': 'translateZ(-' + box.depth.active + 'px)'
            })
            ;
            $activeSide
            .css({
              'transform': 'rotateY(0deg) translateZ(' + box.depth.active
              + 'px)'
            })
            ;
            $nextSide
            .addClass(className.animating)
            .css({
              'top': box.origin + 'px',
              'transform': 'rotateX(-90deg) translateZ(' + box.depth.next
              + 'px)'
            })
            ;
          },

          left: function () {
            var
                height = {
                  active: $activeSide.outerWidth(true),
                  next: $nextSide.outerWidth(true)
                },
                box = {
                  origin: ( ( height.active - height.next ) / 2),
                  depth: {
                    active: (height.next / 2),
                    next: (height.active / 2)
                  }
                }
            ;
            module.verbose('Setting the initial animation position as left',
                $nextSide, box);
            $sides
            .css({
              'transform': 'translateZ(-' + box.depth.active + 'px)'
            })
            ;
            $activeSide
            .css({
              'transform': 'rotateY(0deg) translateZ(' + box.depth.active
              + 'px)'
            })
            ;
            $nextSide
            .addClass(className.animating)
            .css({
              'left': box.origin + 'px',
              'transform': 'rotateY(-90deg) translateZ(' + box.depth.next
              + 'px)'
            })
            ;
          },

          right: function () {
            var
                height = {
                  active: $activeSide.outerWidth(true),
                  next: $nextSide.outerWidth(true)
                },
                box = {
                  origin: ( ( height.active - height.next ) / 2),
                  depth: {
                    active: (height.next / 2),
                    next: (height.active / 2)
                  }
                }
            ;
            module.verbose('Setting the initial animation position as left',
                $nextSide, box);
            $sides
            .css({
              'transform': 'translateZ(-' + box.depth.active + 'px)'
            })
            ;
            $activeSide
            .css({
              'transform': 'rotateY(0deg) translateZ(' + box.depth.active
              + 'px)'
            })
            ;
            $nextSide
            .addClass(className.animating)
            .css({
              'left': box.origin + 'px',
              'transform': 'rotateY(90deg) translateZ(' + box.depth.next + 'px)'
            })
            ;
          },

          behind: function () {
            var
                height = {
                  active: $activeSide.outerWidth(true),
                  next: $nextSide.outerWidth(true)
                },
                box = {
                  origin: ( ( height.active - height.next ) / 2),
                  depth: {
                    active: (height.next / 2),
                    next: (height.active / 2)
                  }
                }
            ;
            module.verbose('Setting the initial animation position as behind',
                $nextSide, box);
            $activeSide
            .css({
              'transform': 'rotateY(0deg)'
            })
            ;
            $nextSide
            .addClass(className.animating)
            .css({
              'left': box.origin + 'px',
              'transform': 'rotateY(-180deg)'
            })
            ;
          }
        },
        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.shape.settings = {

    // module info
    name: 'Shape',

    // hide all debug content
    silent: false,

    // debug content outputted to console
    debug: false,

    // verbose debug output
    verbose: false,

    // fudge factor in pixels when swapping from 2d to 3d (can be useful to correct rounding errors)
    jitter: 0,

    // performance data output
    performance: true,

    // event namespace
    namespace: 'shape',

    // width during animation, can be set to 'auto', initial', 'next' or pixel amount
    width: 'initial',

    // height during animation, can be set to 'auto', 'initial', 'next' or pixel amount
    height: 'initial',

    // callback occurs on side change
    beforeChange: function () {
    },
    onChange: function () {
    },

    // allow animation to same side
    allowRepeats: false,

    // animation duration
    duration: false,

    // possible errors
    error: {
      side: 'You tried to switch to a side that does not exist.',
      method: 'The method you called is not defined'
    },

    // classnames used
    className: {
      animating: 'animating',
      hidden: 'hidden',
      loading: 'loading',
      active: 'active'
    },

    // selectors used
    selector: {
      sides: '.sides',
      side: '.side'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Sidebar
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.sidebar = function (parameters) {
    var
        $allModules = $(this),
        $window = $(window),
        $document = $(document),
        $html = $('html'),
        $head = $('head'),

        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) {
              setTimeout(callback, 0);
            },

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.sidebar.settings, parameters)
              : $.extend({}, $.fn.sidebar.settings),

          selector = settings.selector,
          className = settings.className,
          namespace = settings.namespace,
          regExp = settings.regExp,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $context = $(settings.context),

          $sidebars = $module.children(selector.sidebar),
          $fixed = $context.children(selector.fixed),
          $pusher = $context.children(selector.pusher),
          $style,

          element = this,
          instance = $module.data(moduleNamespace),

          elementNamespace,
          id,
          currentScroll,
          transitionEvent,

          module
      ;

      module = {

        initialize: function () {
          module.debug('Initializing sidebar', parameters);

          module.create.id();

          transitionEvent = module.get.transitionEvent();

          if (module.is.ios()) {
            module.set.ios();
          }

          // avoids locking rendering if initialized in onReady
          if (settings.delaySetup) {
            requestAnimationFrame(module.setup.layout);
          }
          else {
            module.setup.layout();
          }

          requestAnimationFrame(function () {
            module.setup.cache();
          });

          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        create: {
          id: function () {
            id = (Math.random().toString(16) + '000000000').substr(2, 8);
            elementNamespace = '.' + id;
            module.verbose('Creating unique id for element', id);
          }
        },

        destroy: function () {
          module.verbose('Destroying previous module for', $module);
          $module
          .off(eventNamespace)
          .removeData(moduleNamespace)
          ;
          if (module.is.ios()) {
            module.remove.ios();
          }
          // bound by uuid
          $context.off(elementNamespace);
          $window.off(elementNamespace);
          $document.off(elementNamespace);
        },

        event: {
          clickaway: function (event) {
            var
                clickedInPusher = ($pusher.find(event.target).length > 0
                || $pusher.is(event.target)),
                clickedContext = ($context.is(event.target))
            ;
            if (clickedInPusher) {
              module.verbose('User clicked on dimmed page');
              module.hide();
            }
            if (clickedContext) {
              module.verbose(
                  'User clicked on dimmable context (scaled out page)');
              module.hide();
            }
          },
          touch: function (event) {
            //event.stopPropagation();
          },
          containScroll: function (event) {
            if (element.scrollTop <= 0) {
              element.scrollTop = 1;
            }
            if ((element.scrollTop + element.offsetHeight)
                >= element.scrollHeight) {
              element.scrollTop = element.scrollHeight - element.offsetHeight
                  - 1;
            }
          },
          scroll: function (event) {
            if ($(event.target).closest(selector.sidebar).length === 0) {
              event.preventDefault();
            }
          }
        },

        bind: {
          clickaway: function () {
            module.verbose('Adding clickaway events to context', $context);
            if (settings.closable) {
              $context
              .on('click' + elementNamespace, module.event.clickaway)
              .on('touchend' + elementNamespace, module.event.clickaway)
              ;
            }
          },
          scrollLock: function () {
            if (settings.scrollLock) {
              module.debug('Disabling page scroll');
              $window
              .on('DOMMouseScroll' + elementNamespace, module.event.scroll)
              ;
            }
            module.verbose('Adding events to contain sidebar scroll');
            $document
            .on('touchmove' + elementNamespace, module.event.touch)
            ;
            $module
            .on('scroll' + eventNamespace, module.event.containScroll)
            ;
          }
        },
        unbind: {
          clickaway: function () {
            module.verbose('Removing clickaway events from context', $context);
            $context.off(elementNamespace);
          },
          scrollLock: function () {
            module.verbose('Removing scroll lock from page');
            $document.off(elementNamespace);
            $window.off(elementNamespace);
            $module.off('scroll' + eventNamespace);
          }
        },

        add: {
          inlineCSS: function () {
            var
                width = module.cache.width || $module.outerWidth(),
                height = module.cache.height || $module.outerHeight(),
                isRTL = module.is.rtl(),
                direction = module.get.direction(),
                distance = {
                  left: width,
                  right: -width,
                  top: height,
                  bottom: -height
                },
                style
            ;

            if (isRTL) {
              module.verbose('RTL detected, flipping widths');
              distance.left = -width;
              distance.right = width;
            }

            style = '<style>';

            if (direction === 'left' || direction === 'right') {
              module.debug('Adding CSS rules for animation distance', width);
              style += ''
                  + ' .ui.visible.' + direction + '.sidebar ~ .fixed,'
                  + ' .ui.visible.' + direction + '.sidebar ~ .pusher {'
                  + '   -webkit-transform: translate3d(' + distance[direction]
                  + 'px, 0, 0);'
                  + '           transform: translate3d(' + distance[direction]
                  + 'px, 0, 0);'
                  + ' }'
              ;
            }
            else if (direction === 'top' || direction == 'bottom') {
              style += ''
                  + ' .ui.visible.' + direction + '.sidebar ~ .fixed,'
                  + ' .ui.visible.' + direction + '.sidebar ~ .pusher {'
                  + '   -webkit-transform: translate3d(0, '
                  + distance[direction] + 'px, 0);'
                  + '           transform: translate3d(0, '
                  + distance[direction] + 'px, 0);'
                  + ' }'
              ;
            }

            /* IE is only browser not to create context with transforms */
            /* https://www.w3.org/Bugs/Public/show_bug.cgi?id=16328 */
            if (module.is.ie()) {
              if (direction === 'left' || direction === 'right') {
                module.debug('Adding CSS rules for animation distance', width);
                style += ''
                    + ' body.pushable > .ui.visible.' + direction
                    + '.sidebar ~ .pusher:after {'
                    + '   -webkit-transform: translate3d(' + distance[direction]
                    + 'px, 0, 0);'
                    + '           transform: translate3d(' + distance[direction]
                    + 'px, 0, 0);'
                    + ' }'
                ;
              }
              else if (direction === 'top' || direction == 'bottom') {
                style += ''
                    + ' body.pushable > .ui.visible.' + direction
                    + '.sidebar ~ .pusher:after {'
                    + '   -webkit-transform: translate3d(0, '
                    + distance[direction] + 'px, 0);'
                    + '           transform: translate3d(0, '
                    + distance[direction] + 'px, 0);'
                    + ' }'
                ;
              }
              /* opposite sides visible forces content overlay */
              style += ''
                  + ' body.pushable > .ui.visible.left.sidebar ~ .ui.visible.right.sidebar ~ .pusher:after,'
                  + ' body.pushable > .ui.visible.right.sidebar ~ .ui.visible.left.sidebar ~ .pusher:after {'
                  + '   -webkit-transform: translate3d(0px, 0, 0);'
                  + '           transform: translate3d(0px, 0, 0);'
                  + ' }'
              ;
            }
            style += '</style>';
            $style = $(style)
            .appendTo($head)
            ;
            module.debug('Adding sizing css to head', $style);
          }
        },

        refresh: function () {
          module.verbose('Refreshing selector cache');
          $context = $(settings.context);
          $sidebars = $context.children(selector.sidebar);
          $pusher = $context.children(selector.pusher);
          $fixed = $context.children(selector.fixed);
          module.clear.cache();
        },

        refreshSidebars: function () {
          module.verbose('Refreshing other sidebars');
          $sidebars = $context.children(selector.sidebar);
        },

        repaint: function () {
          module.verbose('Forcing repaint event');
          element.style.display = 'none';
          var ignored = element.offsetHeight;
          element.scrollTop = element.scrollTop;
          element.style.display = '';
        },

        setup: {
          cache: function () {
            module.cache = {
              width: $module.outerWidth(),
              height: $module.outerHeight(),
              rtl: ($module.css('direction') == 'rtl')
            };
          },
          layout: function () {
            if ($context.children(selector.pusher).length === 0) {
              module.debug('Adding wrapper element for sidebar');
              module.error(error.pusher);
              $pusher = $('<div class="pusher" />');
              $context
              .children()
              .not(selector.omitted)
              .not($sidebars)
              .wrapAll($pusher)
              ;
              module.refresh();
            }
            if ($module.nextAll(selector.pusher).length === 0
                || $module.nextAll(selector.pusher)[0] !== $pusher[0]) {
              module.debug('Moved sidebar to correct parent element');
              module.error(error.movedSidebar, element);
              $module.detach().prependTo($context);
              module.refresh();
            }
            module.clear.cache();
            module.set.pushable();
            module.set.direction();
          }
        },

        attachEvents: function (selector, event) {
          var
              $toggle = $(selector)
          ;
          event = $.isFunction(module[event])
              ? module[event]
              : module.toggle
          ;
          if ($toggle.length > 0) {
            module.debug('Attaching sidebar events to element', selector,
                event);
            $toggle
            .on('click' + eventNamespace, event)
            ;
          }
          else {
            module.error(error.notFound, selector);
          }
        },

        show: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (module.is.hidden()) {
            module.refreshSidebars();
            if (settings.overlay) {
              module.error(error.overlay);
              settings.transition = 'overlay';
            }
            module.refresh();
            if (module.othersActive()) {
              module.debug('Other sidebars currently visible');
              if (settings.exclusive) {
                // if not overlay queue animation after hide
                if (settings.transition != 'overlay') {
                  module.hideOthers(module.show);
                  return;
                }
                else {
                  module.hideOthers();
                }
              }
              else {
                settings.transition = 'overlay';
              }
            }
            module.pushPage(function () {
              callback.call(element);
              settings.onShow.call(element);
            });
            settings.onChange.call(element);
            settings.onVisible.call(element);
          }
          else {
            module.debug('Sidebar is already visible');
          }
        },

        hide: function (callback) {
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (module.is.visible() || module.is.animating()) {
            module.debug('Hiding sidebar', callback);
            module.refreshSidebars();
            module.pullPage(function () {
              callback.call(element);
              settings.onHidden.call(element);
            });
            settings.onChange.call(element);
            settings.onHide.call(element);
          }
        },

        othersAnimating: function () {
          return ($sidebars.not($module).filter(
              '.' + className.animating).length > 0);
        },
        othersVisible: function () {
          return ($sidebars.not($module).filter('.' + className.visible).length
          > 0);
        },
        othersActive: function () {
          return (module.othersVisible() || module.othersAnimating());
        },

        hideOthers: function (callback) {
          var
              $otherSidebars = $sidebars.not($module).filter(
                  '.' + className.visible),
              sidebarCount = $otherSidebars.length,
              callbackCount = 0
          ;
          callback = callback || function () {
              };
          $otherSidebars
          .sidebar('hide', function () {
            callbackCount++;
            if (callbackCount == sidebarCount) {
              callback();
            }
          })
          ;
        },

        toggle: function () {
          module.verbose('Determining toggled direction');
          if (module.is.hidden()) {
            module.show();
          }
          else {
            module.hide();
          }
        },

        pushPage: function (callback) {
          var
              transition = module.get.transition(),
              $transition = (transition === 'overlay' || module.othersActive())
                  ? $module
                  : $pusher,
              animate,
              dim,
              transitionEnd
          ;
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          if (settings.transition == 'scale down') {
            module.scrollToTop();
          }
          module.set.transition(transition);
          module.repaint();
          animate = function () {
            module.bind.clickaway();
            module.add.inlineCSS();
            module.set.animating();
            module.set.visible();
          };
          dim = function () {
            module.set.dimmed();
          };
          transitionEnd = function (event) {
            if (event.target == $transition[0]) {
              $transition.off(transitionEvent + elementNamespace,
                  transitionEnd);
              module.remove.animating();
              module.bind.scrollLock();
              callback.call(element);
            }
          };
          $transition.off(transitionEvent + elementNamespace);
          $transition.on(transitionEvent + elementNamespace, transitionEnd);
          requestAnimationFrame(animate);
          if (settings.dimPage && !module.othersVisible()) {
            requestAnimationFrame(dim);
          }
        },

        pullPage: function (callback) {
          var
              transition = module.get.transition(),
              $transition = (transition == 'overlay' || module.othersActive())
                  ? $module
                  : $pusher,
              animate,
              transitionEnd
          ;
          callback = $.isFunction(callback)
              ? callback
              : function () {
              }
          ;
          module.verbose('Removing context push state', module.get.direction());

          module.unbind.clickaway();
          module.unbind.scrollLock();

          animate = function () {
            module.set.transition(transition);
            module.set.animating();
            module.remove.visible();
            if (settings.dimPage && !module.othersVisible()) {
              $pusher.removeClass(className.dimmed);
            }
          };
          transitionEnd = function (event) {
            if (event.target == $transition[0]) {
              $transition.off(transitionEvent + elementNamespace,
                  transitionEnd);
              module.remove.animating();
              module.remove.transition();
              module.remove.inlineCSS();
              if (transition == 'scale down' || (settings.returnScroll
                  && module.is.mobile())) {
                module.scrollBack();
              }
              callback.call(element);
            }
          };
          $transition.off(transitionEvent + elementNamespace);
          $transition.on(transitionEvent + elementNamespace, transitionEnd);
          requestAnimationFrame(animate);
        },

        scrollToTop: function () {
          module.verbose('Scrolling to top of page to avoid animation issues');
          currentScroll = $(window).scrollTop();
          $module.scrollTop(0);
          window.scrollTo(0, 0);
        },

        scrollBack: function () {
          module.verbose('Scrolling back to original page position');
          window.scrollTo(0, currentScroll);
        },

        clear: {
          cache: function () {
            module.verbose('Clearing cached dimensions');
            module.cache = {};
          }
        },

        set: {

          // ios only (scroll on html not document). This prevent auto-resize canvas/scroll in ios
          ios: function () {
            $html.addClass(className.ios);
          },

          // container
          pushed: function () {
            $context.addClass(className.pushed);
          },
          pushable: function () {
            $context.addClass(className.pushable);
          },

          // pusher
          dimmed: function () {
            $pusher.addClass(className.dimmed);
          },

          // sidebar
          active: function () {
            $module.addClass(className.active);
          },
          animating: function () {
            $module.addClass(className.animating);
          },
          transition: function (transition) {
            transition = transition || module.get.transition();
            $module.addClass(transition);
          },
          direction: function (direction) {
            direction = direction || module.get.direction();
            $module.addClass(className[direction]);
          },
          visible: function () {
            $module.addClass(className.visible);
          },
          overlay: function () {
            $module.addClass(className.overlay);
          }
        },
        remove: {

          inlineCSS: function () {
            module.debug('Removing inline css styles', $style);
            if ($style && $style.length > 0) {
              $style.remove();
            }
          },

          // ios scroll on html not document
          ios: function () {
            $html.removeClass(className.ios);
          },

          // context
          pushed: function () {
            $context.removeClass(className.pushed);
          },
          pushable: function () {
            $context.removeClass(className.pushable);
          },

          // sidebar
          active: function () {
            $module.removeClass(className.active);
          },
          animating: function () {
            $module.removeClass(className.animating);
          },
          transition: function (transition) {
            transition = transition || module.get.transition();
            $module.removeClass(transition);
          },
          direction: function (direction) {
            direction = direction || module.get.direction();
            $module.removeClass(className[direction]);
          },
          visible: function () {
            $module.removeClass(className.visible);
          },
          overlay: function () {
            $module.removeClass(className.overlay);
          }
        },

        get: {
          direction: function () {
            if ($module.hasClass(className.top)) {
              return className.top;
            }
            else if ($module.hasClass(className.right)) {
              return className.right;
            }
            else if ($module.hasClass(className.bottom)) {
              return className.bottom;
            }
            return className.left;
          },
          transition: function () {
            var
                direction = module.get.direction(),
                transition
            ;
            transition = ( module.is.mobile() )
                ? (settings.mobileTransition == 'auto')
                    ? settings.defaultTransition.mobile[direction]
                    : settings.mobileTransition
                : (settings.transition == 'auto')
                    ? settings.defaultTransition.computer[direction]
                    : settings.transition
            ;
            module.verbose('Determined transition', transition);
            return transition;
          },
          transitionEvent: function () {
            var
                element = document.createElement('element'),
                transitions = {
                  'transition': 'transitionend',
                  'OTransition': 'oTransitionEnd',
                  'MozTransition': 'transitionend',
                  'WebkitTransition': 'webkitTransitionEnd'
                },
                transition
            ;
            for (transition in transitions) {
              if (element.style[transition] !== undefined) {
                return transitions[transition];
              }
            }
          }
        },

        is: {

          ie: function () {
            var
                isIE11 = (!(window.ActiveXObject) && 'ActiveXObject' in window),
                isIE = ('ActiveXObject' in window)
            ;
            return (isIE11 || isIE);
          },

          ios: function () {
            var
                userAgent = navigator.userAgent,
                isIOS = userAgent.match(regExp.ios),
                isMobileChrome = userAgent.match(regExp.mobileChrome)
            ;
            if (isIOS && !isMobileChrome) {
              module.verbose('Browser was found to be iOS', userAgent);
              return true;
            }
            else {
              return false;
            }
          },
          mobile: function () {
            var
                userAgent = navigator.userAgent,
                isMobile = userAgent.match(regExp.mobile)
            ;
            if (isMobile) {
              module.verbose('Browser was found to be mobile', userAgent);
              return true;
            }
            else {
              module.verbose('Browser is not mobile, using regular transition',
                  userAgent);
              return false;
            }
          },
          hidden: function () {
            return !module.is.visible();
          },
          visible: function () {
            return $module.hasClass(className.visible);
          },
          // alias
          open: function () {
            return module.is.visible();
          },
          closed: function () {
            return module.is.hidden();
          },
          vertical: function () {
            return $module.hasClass(className.top);
          },
          animating: function () {
            return $context.hasClass(className.animating);
          },
          rtl: function () {
            if (module.cache.rtl === undefined) {
              module.cache.rtl = ($module.css('direction') == 'rtl');
            }
            return module.cache.rtl;
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      }
      ;

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          module.invoke('destroy');
        }
        module.initialize();
      }
    });

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.sidebar.settings = {

    name: 'Sidebar',
    namespace: 'sidebar',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    transition: 'auto',
    mobileTransition: 'auto',

    defaultTransition: {
      computer: {
        left: 'uncover',
        right: 'uncover',
        top: 'overlay',
        bottom: 'overlay'
      },
      mobile: {
        left: 'uncover',
        right: 'uncover',
        top: 'overlay',
        bottom: 'overlay'
      }
    },

    context: 'body',
    exclusive: false,
    closable: true,
    dimPage: true,
    scrollLock: false,
    returnScroll: false,
    delaySetup: false,

    duration: 500,

    onChange: function () {
    },
    onShow: function () {
    },
    onHide: function () {
    },

    onHidden: function () {
    },
    onVisible: function () {
    },

    className: {
      active: 'active',
      animating: 'animating',
      dimmed: 'dimmed',
      ios: 'ios',
      pushable: 'pushable',
      pushed: 'pushed',
      right: 'right',
      top: 'top',
      left: 'left',
      bottom: 'bottom',
      visible: 'visible'
    },

    selector: {
      fixed: '.fixed',
      omitted: 'script, link, style, .ui.modal, .ui.dimmer, .ui.nag, .ui.fixed',
      pusher: '.pusher',
      sidebar: '.ui.sidebar'
    },

    regExp: {
      ios: /(iPad|iPhone|iPod)/g,
      mobileChrome: /(CriOS)/g,
      mobile: /Mobile|iP(hone|od|ad)|Android|BlackBerry|IEMobile|Kindle|NetFront|Silk-Accelerated|(hpw|web)OS|Fennec|Minimo|Opera M(obi|ini)|Blazer|Dolfin|Dolphin|Skyfire|Zune/g
    },

    error: {
      method: 'The method you called is not defined.',
      pusher: 'Had to add pusher element. For optimal performance make sure body content is inside a pusher element',
      movedSidebar: 'Had to move sidebar. For optimal performance make sure sidebar and pusher are direct children of your body tag',
      overlay: 'The overlay setting is no longer supported, use animation: overlay',
      notFound: 'There were no elements that matched the specified selector'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Sticky
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.sticky = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.sticky.settings, parameters)
              : $.extend({}, $.fn.sticky.settings),

          className = settings.className,
          namespace = settings.namespace,
          error = settings.error,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $module = $(this),
          $window = $(window),
          $scroll = $(settings.scrollContext),
          $container,
          $context,

          selector = $module.selector || '',
          instance = $module.data(moduleNamespace),

          requestAnimationFrame = window.requestAnimationFrame
              || window.mozRequestAnimationFrame
              || window.webkitRequestAnimationFrame
              || window.msRequestAnimationFrame
              || function (callback) {
                setTimeout(callback, 0);
              },

          element = this,

          documentObserver,
          observer,
          module
      ;

      module = {

        initialize: function () {

          module.determineContainer();
          module.determineContext();
          module.verbose('Initializing sticky', settings, $container);

          module.save.positions();
          module.checkErrors();
          module.bind.events();

          if (settings.observeChanges) {
            module.observeChanges();
          }
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous instance');
          module.reset();
          if (documentObserver) {
            documentObserver.disconnect();
          }
          if (observer) {
            observer.disconnect();
          }
          $window
          .off('load' + eventNamespace, module.event.load)
          .off('resize' + eventNamespace, module.event.resize)
          ;
          $scroll
          .off('scrollchange' + eventNamespace, module.event.scrollchange)
          ;
          $module.removeData(moduleNamespace);
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            documentObserver = new MutationObserver(
                module.event.documentChanged);
            observer = new MutationObserver(module.event.changed);
            documentObserver.observe(document, {
              childList: true,
              subtree: true
            });
            observer.observe(element, {
              childList: true,
              subtree: true
            });
            observer.observe($context[0], {
              childList: true,
              subtree: true
            });
            module.debug('Setting up mutation observer', observer);
          }
        },

        determineContainer: function () {
          if (settings.container) {
            $container = $(settings.container);
          }
          else {
            $container = $module.offsetParent();
          }
        },

        determineContext: function () {
          if (settings.context) {
            $context = $(settings.context);
          }
          else {
            $context = $container;
          }
          if ($context.length === 0) {
            module.error(error.invalidContext, settings.context, $module);
            return;
          }
        },

        checkErrors: function () {
          if (module.is.hidden()) {
            module.error(error.visible, $module);
          }
          if (module.cache.element.height > module.cache.context.height) {
            module.reset();
            module.error(error.elementSize, $module);
            return;
          }
        },

        bind: {
          events: function () {
            $window
            .on('load' + eventNamespace, module.event.load)
            .on('resize' + eventNamespace, module.event.resize)
            ;
            // pub/sub pattern
            $scroll
            .off('scroll' + eventNamespace)
            .on('scroll' + eventNamespace, module.event.scroll)
            .on('scrollchange' + eventNamespace, module.event.scrollchange)
            ;
          }
        },

        event: {
          changed: function (mutations) {
            clearTimeout(module.timer);
            module.timer = setTimeout(function () {
              module.verbose('DOM tree modified, updating sticky menu',
                  mutations);
              module.refresh();
            }, 100);
          },
          documentChanged: function (mutations) {
            [].forEach.call(mutations, function (mutation) {
              if (mutation.removedNodes) {
                [].forEach.call(mutation.removedNodes, function (node) {
                  if (node == element || $(node).find(element).length > 0) {
                    module.debug(
                        'Element removed from DOM, tearing down events');
                    module.destroy();
                  }
                });
              }
            });
          },
          load: function () {
            module.verbose('Page contents finished loading');
            requestAnimationFrame(module.refresh);
          },
          resize: function () {
            module.verbose('Window resized');
            requestAnimationFrame(module.refresh);
          },
          scroll: function () {
            requestAnimationFrame(function () {
              $scroll.triggerHandler('scrollchange' + eventNamespace,
                  $scroll.scrollTop());
            });
          },
          scrollchange: function (event, scrollPosition) {
            module.stick(scrollPosition);
            settings.onScroll.call(element);
          }
        },

        refresh: function (hardRefresh) {
          module.reset();
          if (!settings.context) {
            module.determineContext();
          }
          if (hardRefresh) {
            module.determineContainer();
          }
          module.save.positions();
          module.stick();
          settings.onReposition.call(element);
        },

        supports: {
          sticky: function () {
            var
                $element = $('<div/>'),
                element = $element[0]
            ;
            $element.addClass(className.supported);
            return ($element.css('position').match('sticky'));
          }
        },

        save: {
          lastScroll: function (scroll) {
            module.lastScroll = scroll;
          },
          elementScroll: function (scroll) {
            module.elementScroll = scroll;
          },
          positions: function () {
            var
                scrollContext = {
                  height: $scroll.height()
                },
                element = {
                  margin: {
                    top: parseInt($module.css('margin-top'), 10),
                    bottom: parseInt($module.css('margin-bottom'), 10),
                  },
                  offset: $module.offset(),
                  width: $module.outerWidth(),
                  height: $module.outerHeight()
                },
                context = {
                  offset: $context.offset(),
                  height: $context.outerHeight()
                },
                container = {
                  height: $container.outerHeight()
                }
            ;
            if (!module.is.standardScroll()) {
              module.debug(
                  'Non-standard scroll. Removing scroll offset from element offset');

              scrollContext.top = $scroll.scrollTop();
              scrollContext.left = $scroll.scrollLeft();

              element.offset.top += scrollContext.top;
              context.offset.top += scrollContext.top;
              element.offset.left += scrollContext.left;
              context.offset.left += scrollContext.left;
            }
            module.cache = {
              fits: ( element.height < scrollContext.height ),
              scrollContext: {
                height: scrollContext.height
              },
              element: {
                margin: element.margin,
                top: element.offset.top - element.margin.top,
                left: element.offset.left,
                width: element.width,
                height: element.height,
                bottom: element.offset.top + element.height
              },
              context: {
                top: context.offset.top,
                height: context.height,
                bottom: context.offset.top + context.height
              }
            };
            module.set.containerSize();
            module.set.size();
            module.stick();
            module.debug('Caching element positions', module.cache);
          }
        },

        get: {
          direction: function (scroll) {
            var
                direction = 'down'
            ;
            scroll = scroll || $scroll.scrollTop();
            if (module.lastScroll !== undefined) {
              if (module.lastScroll < scroll) {
                direction = 'down';
              }
              else if (module.lastScroll > scroll) {
                direction = 'up';
              }
            }
            return direction;
          },
          scrollChange: function (scroll) {
            scroll = scroll || $scroll.scrollTop();
            return (module.lastScroll)
                ? (scroll - module.lastScroll)
                : 0
                ;
          },
          currentElementScroll: function () {
            if (module.elementScroll) {
              return module.elementScroll;
            }
            return ( module.is.top() )
                ? Math.abs(parseInt($module.css('top'), 10)) || 0
                : Math.abs(parseInt($module.css('bottom'), 10)) || 0
                ;
          },

          elementScroll: function (scroll) {
            scroll = scroll || $scroll.scrollTop();
            var
                element = module.cache.element,
                scrollContext = module.cache.scrollContext,
                delta = module.get.scrollChange(scroll),
                maxScroll = (element.height - scrollContext.height
                + settings.offset),
                elementScroll = module.get.currentElementScroll(),
                possibleScroll = (elementScroll + delta)
            ;
            if (module.cache.fits || possibleScroll < 0) {
              elementScroll = 0;
            }
            else if (possibleScroll > maxScroll) {
              elementScroll = maxScroll;
            }
            else {
              elementScroll = possibleScroll;
            }
            return elementScroll;
          }
        },

        remove: {
          lastScroll: function () {
            delete module.lastScroll;
          },
          elementScroll: function (scroll) {
            delete module.elementScroll;
          },
          offset: function () {
            $module.css('margin-top', '');
          }
        },

        set: {
          offset: function () {
            module.verbose('Setting offset on element', settings.offset);
            $module
            .css('margin-top', settings.offset)
            ;
          },
          containerSize: function () {
            var
                tagName = $container.get(0).tagName
            ;
            if (tagName === 'HTML' || tagName == 'body') {
              // this can trigger for too many reasons
              //module.error(error.container, tagName, $module);
              module.determineContainer();
            }
            else {
              if (Math.abs(
                      $container.outerHeight() - module.cache.context.height)
                  > settings.jitter) {
                module.debug(
                    'Context has padding, specifying exact height for container',
                    module.cache.context.height);
                $container.css({
                  height: module.cache.context.height
                });
              }
            }
          },
          minimumSize: function () {
            var
                element = module.cache.element
            ;
            $container
            .css('min-height', element.height)
            ;
          },
          scroll: function (scroll) {
            module.debug('Setting scroll on element', scroll);
            if (module.elementScroll == scroll) {
              return;
            }
            if (module.is.top()) {
              $module
              .css('bottom', '')
              .css('top', -scroll)
              ;
            }
            if (module.is.bottom()) {
              $module
              .css('top', '')
              .css('bottom', scroll)
              ;
            }
          },
          size: function () {
            if (module.cache.element.height !== 0 && module.cache.element.width
                !== 0) {
              element.style.setProperty('width',
                  module.cache.element.width + 'px', 'important');
              element.style.setProperty('height',
                  module.cache.element.height + 'px', 'important');
            }
          }
        },

        is: {
          standardScroll: function () {
            return ($scroll[0] == window);
          },
          top: function () {
            return $module.hasClass(className.top);
          },
          bottom: function () {
            return $module.hasClass(className.bottom);
          },
          initialPosition: function () {
            return (!module.is.fixed() && !module.is.bound());
          },
          hidden: function () {
            return (!$module.is(':visible'));
          },
          bound: function () {
            return $module.hasClass(className.bound);
          },
          fixed: function () {
            return $module.hasClass(className.fixed);
          }
        },

        stick: function (scroll) {
          var
              cachedPosition = scroll || $scroll.scrollTop(),
              cache = module.cache,
              fits = cache.fits,
              element = cache.element,
              scrollContext = cache.scrollContext,
              context = cache.context,
              offset = (module.is.bottom() && settings.pushing)
                  ? settings.bottomOffset
                  : settings.offset,
              scroll = {
                top: cachedPosition + offset,
                bottom: cachedPosition + offset + scrollContext.height
              },
              direction = module.get.direction(scroll.top),
              elementScroll = (fits)
                  ? 0
                  : module.get.elementScroll(scroll.top),

              // shorthand
              doesntFit = !fits,
              elementVisible = (element.height !== 0)
          ;

          if (elementVisible) {

            if (module.is.initialPosition()) {
              if (scroll.top >= context.bottom) {
                module.debug('Initial element position is bottom of container');
                module.bindBottom();
              }
              else if (scroll.top > element.top) {
                if ((element.height + scroll.top - elementScroll)
                    >= context.bottom) {
                  module.debug(
                      'Initial element position is bottom of container');
                  module.bindBottom();
                }
                else {
                  module.debug('Initial element position is fixed');
                  module.fixTop();
                }
              }

            }
            else if (module.is.fixed()) {

              // currently fixed top
              if (module.is.top()) {
                if (scroll.top <= element.top) {
                  module.debug('Fixed element reached top of container');
                  module.setInitialPosition();
                }
                else if ((element.height + scroll.top - elementScroll)
                    >= context.bottom) {
                  module.debug('Fixed element reached bottom of container');
                  module.bindBottom();
                }
                // scroll element if larger than screen
                else if (doesntFit) {
                  module.set.scroll(elementScroll);
                  module.save.lastScroll(scroll.top);
                  module.save.elementScroll(elementScroll);
                }
              }

              // currently fixed bottom
              else if (module.is.bottom()) {

                // top edge
                if ((scroll.bottom - element.height) <= element.top) {
                  module.debug(
                      'Bottom fixed rail has reached top of container');
                  module.setInitialPosition();
                }
                // bottom edge
                else if (scroll.bottom >= context.bottom) {
                  module.debug(
                      'Bottom fixed rail has reached bottom of container');
                  module.bindBottom();
                }
                // scroll element if larger than screen
                else if (doesntFit) {
                  module.set.scroll(elementScroll);
                  module.save.lastScroll(scroll.top);
                  module.save.elementScroll(elementScroll);
                }

              }
            }
            else if (module.is.bottom()) {
              if (scroll.top <= element.top) {
                module.debug(
                    'Jumped from bottom fixed to top fixed, most likely used home/end button');
                module.setInitialPosition();
              }
              else {
                if (settings.pushing) {
                  if (module.is.bound() && scroll.bottom <= context.bottom) {
                    module.debug(
                        'Fixing bottom attached element to bottom of browser.');
                    module.fixBottom();
                  }
                }
                else {
                  if (module.is.bound() && (scroll.top <= context.bottom
                      - element.height)) {
                    module.debug(
                        'Fixing bottom attached element to top of browser.');
                    module.fixTop();
                  }
                }
              }
            }
          }
        },

        bindTop: function () {
          module.debug('Binding element to top of parent container');
          module.remove.offset();
          $module
          .css({
            left: '',
            top: '',
            marginBottom: ''
          })
          .removeClass(className.fixed)
          .removeClass(className.bottom)
          .addClass(className.bound)
          .addClass(className.top)
          ;
          settings.onTop.call(element);
          settings.onUnstick.call(element);
        },
        bindBottom: function () {
          module.debug('Binding element to bottom of parent container');
          module.remove.offset();
          $module
          .css({
            left: '',
            top: ''
          })
          .removeClass(className.fixed)
          .removeClass(className.top)
          .addClass(className.bound)
          .addClass(className.bottom)
          ;
          settings.onBottom.call(element);
          settings.onUnstick.call(element);
        },

        setInitialPosition: function () {
          module.debug('Returning to initial position');
          module.unfix();
          module.unbind();
        },

        fixTop: function () {
          module.debug('Fixing element to top of page');
          module.set.minimumSize();
          module.set.offset();
          $module
          .css({
            left: module.cache.element.left,
            bottom: '',
            marginBottom: ''
          })
          .removeClass(className.bound)
          .removeClass(className.bottom)
          .addClass(className.fixed)
          .addClass(className.top)
          ;
          settings.onStick.call(element);
        },

        fixBottom: function () {
          module.debug('Sticking element to bottom of page');
          module.set.minimumSize();
          module.set.offset();
          $module
          .css({
            left: module.cache.element.left,
            bottom: '',
            marginBottom: ''
          })
          .removeClass(className.bound)
          .removeClass(className.top)
          .addClass(className.fixed)
          .addClass(className.bottom)
          ;
          settings.onStick.call(element);
        },

        unbind: function () {
          if (module.is.bound()) {
            module.debug('Removing container bound position on element');
            module.remove.offset();
            $module
            .removeClass(className.bound)
            .removeClass(className.top)
            .removeClass(className.bottom)
            ;
          }
        },

        unfix: function () {
          if (module.is.fixed()) {
            module.debug('Removing fixed position on element');
            module.remove.offset();
            $module
            .removeClass(className.fixed)
            .removeClass(className.top)
            .removeClass(className.bottom)
            ;
            settings.onUnstick.call(element);
          }
        },

        reset: function () {
          module.debug('Resetting elements position');
          module.unbind();
          module.unfix();
          module.resetCSS();
          module.remove.offset();
          module.remove.lastScroll();
        },

        resetCSS: function () {
          $module
          .css({
            width: '',
            height: ''
          })
          ;
          $container
          .css({
            height: ''
          })
          ;
        },

        setting: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            settings[name] = value;
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                0);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.sticky.settings = {

    name: 'Sticky',
    namespace: 'sticky',

    silent: false,
    debug: false,
    verbose: true,
    performance: true,

    // whether to stick in the opposite direction on scroll up
    pushing: false,

    context: false,
    container: false,

    // Context to watch scroll events
    scrollContext: window,

    // Offset to adjust scroll
    offset: 0,

    // Offset to adjust scroll when attached to bottom of screen
    bottomOffset: 0,

    jitter: 5, // will only set container height if difference between context and container is larger than this number

    // Whether to automatically observe changes with Mutation Observers
    observeChanges: false,

    // Called when position is recalculated
    onReposition: function () {
    },

    // Called on each scroll
    onScroll: function () {
    },

    // Called when element is stuck to viewport
    onStick: function () {
    },

    // Called when element is unstuck from viewport
    onUnstick: function () {
    },

    // Called when element reaches top of context
    onTop: function () {
    },

    // Called when element reaches bottom of context
    onBottom: function () {
    },

    error: {
      container: 'Sticky element must be inside a relative container',
      visible: 'Element is hidden, you must call refresh after element becomes visible. Use silent setting to surpress this warning in production.',
      method: 'The method you called is not defined.',
      invalidContext: 'Context specified does not exist',
      elementSize: 'Sticky element is larger than its container, cannot create sticky.'
    },

    className: {
      bound: 'bound',
      fixed: 'fixed',
      supported: 'native',
      top: 'top',
      bottom: 'bottom'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Tab
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.tab = function (parameters) {

    var
        // use window context if none specified
        $allModules = $.isFunction(this)
            ? $(window)
            : $(this),

        moduleSelector = $allModules.selector || '',
        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        initializedHistory = false,
        returnedValue
    ;

    $allModules
    .each(function () {
      var

          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.tab.settings, parameters)
              : $.extend({}, $.fn.tab.settings),

          className = settings.className,
          metadata = settings.metadata,
          selector = settings.selector,
          error = settings.error,

          eventNamespace = '.' + settings.namespace,
          moduleNamespace = 'module-' + settings.namespace,

          $module = $(this),
          $context,
          $tabs,

          cache = {},
          firstLoad = true,
          recursionDepth = 0,
          element = this,
          instance = $module.data(moduleNamespace),

          activeTabPath,
          parameterArray,
          module,

          historyEvent

      ;

      module = {

        initialize: function () {
          module.debug('Initializing tab menu item', $module);
          module.fix.callbacks();
          module.determineTabs();

          module.debug('Determining tabs', settings.context, $tabs);
          // set up automatic routing
          if (settings.auto) {
            module.set.auto();
          }
          module.bind.events();

          if (settings.history && !initializedHistory) {
            module.initializeHistory();
            initializedHistory = true;
          }

          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.debug('Destroying tabs', $module);
          $module
          .removeData(moduleNamespace)
          .off(eventNamespace)
          ;
        },

        bind: {
          events: function () {
            // if using $.tab don't add events
            if (!$.isWindow(element)) {
              module.debug('Attaching tab activation events to element',
                  $module);
              $module
              .on('click' + eventNamespace, module.event.click)
              ;
            }
          }
        },

        determineTabs: function () {
          var
              $reference
          ;

          // determine tab context
          if (settings.context === 'parent') {
            if ($module.closest(selector.ui).length > 0) {
              $reference = $module.closest(selector.ui);
              module.verbose('Using closest UI element as parent', $reference);
            }
            else {
              $reference = $module;
            }
            $context = $reference.parent();
            module.verbose('Determined parent element for creating context',
                $context);
          }
          else if (settings.context) {
            $context = $(settings.context);
            module.verbose('Using selector for tab context', settings.context,
                $context);
          }
          else {
            $context = $('body');
          }
          // find tabs
          if (settings.childrenOnly) {
            $tabs = $context.children(selector.tabs);
            module.debug('Searching tab context children for tabs', $context,
                $tabs);
          }
          else {
            $tabs = $context.find(selector.tabs);
            module.debug('Searching tab context for tabs', $context, $tabs);
          }
        },

        fix: {
          callbacks: function () {
            if ($.isPlainObject(parameters) && (parameters.onTabLoad
                || parameters.onTabInit)) {
              if (parameters.onTabLoad) {
                parameters.onLoad = parameters.onTabLoad;
                delete parameters.onTabLoad;
                module.error(error.legacyLoad, parameters.onLoad);
              }
              if (parameters.onTabInit) {
                parameters.onFirstLoad = parameters.onTabInit;
                delete parameters.onTabInit;
                module.error(error.legacyInit, parameters.onFirstLoad);
              }
              settings = $.extend(true, {}, $.fn.tab.settings, parameters);
            }
          }
        },

        initializeHistory: function () {
          module.debug('Initializing page state');
          if ($.address === undefined) {
            module.error(error.state);
            return false;
          }
          else {
            if (settings.historyType == 'state') {
              module.debug('Using HTML5 to manage state');
              if (settings.path !== false) {
                $.address
                .history(true)
                .state(settings.path)
                ;
              }
              else {
                module.error(error.path);
                return false;
              }
            }
            $.address
            .bind('change', module.event.history.change)
            ;
          }
        },

        event: {
          click: function (event) {
            var
                tabPath = $(this).data(metadata.tab)
            ;
            if (tabPath !== undefined) {
              if (settings.history) {
                module.verbose('Updating page state', event);
                $.address.value(tabPath);
              }
              else {
                module.verbose('Changing tab', event);
                module.changeTab(tabPath);
              }
              event.preventDefault();
            }
            else {
              module.debug('No tab specified');
            }
          },
          history: {
            change: function (event) {
              var
                  tabPath = event.pathNames.join('/')
                      || module.get.initialPath(),
                  pageTitle = settings.templates.determineTitle(tabPath)
                      || false
              ;
              module.performance.display();
              module.debug('History change event', tabPath, event);
              historyEvent = event;
              if (tabPath !== undefined) {
                module.changeTab(tabPath);
              }
              if (pageTitle) {
                $.address.title(pageTitle);
              }
            }
          }
        },

        refresh: function () {
          if (activeTabPath) {
            module.debug('Refreshing tab', activeTabPath);
            module.changeTab(activeTabPath);
          }
        },

        cache: {

          read: function (cacheKey) {
            return (cacheKey !== undefined)
                ? cache[cacheKey]
                : false
                ;
          },
          add: function (cacheKey, content) {
            cacheKey = cacheKey || activeTabPath;
            module.debug('Adding cached content for', cacheKey);
            cache[cacheKey] = content;
          },
          remove: function (cacheKey) {
            cacheKey = cacheKey || activeTabPath;
            module.debug('Removing cached content for', cacheKey);
            delete cache[cacheKey];
          }
        },

        set: {
          auto: function () {
            var
                url = (typeof settings.path == 'string')
                    ? settings.path.replace(/\/$/, '') + '/{$tab}'
                    : '/{$tab}'
            ;
            module.verbose('Setting up automatic tab retrieval from server',
                url);
            if ($.isPlainObject(settings.apiSettings)) {
              settings.apiSettings.url = url;
            }
            else {
              settings.apiSettings = {
                url: url
              };
            }
          },
          loading: function (tabPath) {
            var
                $tab = module.get.tabElement(tabPath),
                isLoading = $tab.hasClass(className.loading)
            ;
            if (!isLoading) {
              module.verbose('Setting loading state for', $tab);
              $tab
              .addClass(className.loading)
              .siblings($tabs)
              .removeClass(className.active + ' ' + className.loading)
              ;
              if ($tab.length > 0) {
                settings.onRequest.call($tab[0], tabPath);
              }
            }
          },
          state: function (state) {
            $.address.value(state);
          }
        },

        changeTab: function (tabPath) {
          var
              pushStateAvailable = (window.history && window.history.pushState),
              shouldIgnoreLoad = (pushStateAvailable && settings.ignoreFirstLoad
              && firstLoad),
              remoteContent = (settings.auto || $.isPlainObject(
                  settings.apiSettings) ),
              // only add default path if not remote content
              pathArray = (remoteContent && !shouldIgnoreLoad)
                  ? module.utilities.pathToArray(tabPath)
                  : module.get.defaultPathArray(tabPath)
          ;
          tabPath = module.utilities.arrayToPath(pathArray);
          $.each(pathArray, function (index, tab) {
            var
                currentPathArray = pathArray.slice(0, index + 1),
                currentPath = module.utilities.arrayToPath(currentPathArray),

                isTab = module.is.tab(currentPath),
                isLastIndex = (index + 1 == pathArray.length),

                $tab = module.get.tabElement(currentPath),
                $anchor,
                nextPathArray,
                nextPath,
                isLastTab
            ;
            module.verbose('Looking for tab', tab);
            if (isTab) {
              module.verbose('Tab was found', tab);
              // scope up
              activeTabPath = currentPath;
              parameterArray = module.utilities.filterArray(pathArray,
                  currentPathArray);

              if (isLastIndex) {
                isLastTab = true;
              }
              else {
                nextPathArray = pathArray.slice(0, index + 2);
                nextPath = module.utilities.arrayToPath(nextPathArray);
                isLastTab = ( !module.is.tab(nextPath) );
                if (isLastTab) {
                  module.verbose('Tab parameters found', nextPathArray);
                }
              }
              if (isLastTab && remoteContent) {
                if (!shouldIgnoreLoad) {
                  module.activate.navigation(currentPath);
                  module.fetch.content(currentPath, tabPath);
                }
                else {
                  module.debug('Ignoring remote content on first tab load',
                      currentPath);
                  firstLoad = false;
                  module.cache.add(tabPath, $tab.html());
                  module.activate.all(currentPath);
                  settings.onFirstLoad.call($tab[0], currentPath,
                      parameterArray, historyEvent);
                  settings.onLoad.call($tab[0], currentPath, parameterArray,
                      historyEvent);
                }
                return false;
              }
              else {
                module.debug('Opened local tab', currentPath);
                module.activate.all(currentPath);
                if (!module.cache.read(currentPath)) {
                  module.cache.add(currentPath, true);
                  module.debug('First time tab loaded calling tab init');
                  settings.onFirstLoad.call($tab[0], currentPath,
                      parameterArray, historyEvent);
                }
                settings.onLoad.call($tab[0], currentPath, parameterArray,
                    historyEvent);
              }

            }
            else if (tabPath.search('/') == -1 && tabPath !== '') {
              // look for in page anchor
              $anchor = $('#' + tabPath + ', a[name="' + tabPath + '"]');
              currentPath = $anchor.closest('[data-tab]').data(metadata.tab);
              $tab = module.get.tabElement(currentPath);
              // if anchor exists use parent tab
              if ($anchor && $anchor.length > 0 && currentPath) {
                module.debug('Anchor link used, opening parent tab', $tab,
                    $anchor);
                if (!$tab.hasClass(className.active)) {
                  setTimeout(function () {
                    module.scrollTo($anchor);
                  }, 0);
                }
                module.activate.all(currentPath);
                if (!module.cache.read(currentPath)) {
                  module.cache.add(currentPath, true);
                  module.debug('First time tab loaded calling tab init');
                  settings.onFirstLoad.call($tab[0], currentPath,
                      parameterArray, historyEvent);
                }
                settings.onLoad.call($tab[0], currentPath, parameterArray,
                    historyEvent);
                return false;
              }
            }
            else {
              module.error(error.missingTab, $module, $context, currentPath);
              return false;
            }
          });
        },

        scrollTo: function ($element) {
          var
              scrollOffset = ($element && $element.length > 0)
                  ? $element.offset().top
                  : false
          ;
          if (scrollOffset !== false) {
            module.debug('Forcing scroll to an in-page link in a hidden tab',
                scrollOffset, $element);
            $(document).scrollTop(scrollOffset);
          }
        },

        update: {
          content: function (tabPath, html, evaluateScripts) {
            var
                $tab = module.get.tabElement(tabPath),
                tab = $tab[0]
            ;
            evaluateScripts = (evaluateScripts !== undefined)
                ? evaluateScripts
                : settings.evaluateScripts
            ;
            if (typeof settings.cacheType == 'string'
                && settings.cacheType.toLowerCase() == 'dom' && typeof html
                !== 'string') {
              $tab
              .empty()
              .append($(html).clone(true))
              ;
            }
            else {
              if (evaluateScripts) {
                module.debug('Updating HTML and evaluating inline scripts',
                    tabPath, html);
                $tab.html(html);
              }
              else {
                module.debug('Updating HTML', tabPath, html);
                tab.innerHTML = html;
              }
            }
          }
        },

        fetch: {

          content: function (tabPath, fullTabPath) {
            var
                $tab = module.get.tabElement(tabPath),
                apiSettings = {
                  dataType: 'html',
                  encodeParameters: false,
                  on: 'now',
                  cache: settings.alwaysRefresh,
                  headers: {
                    'X-Remote': true
                  },
                  onSuccess: function (response) {
                    if (settings.cacheType == 'response') {
                      module.cache.add(fullTabPath, response);
                    }
                    module.update.content(tabPath, response);
                    if (tabPath == activeTabPath) {
                      module.debug('Content loaded', tabPath);
                      module.activate.tab(tabPath);
                    }
                    else {
                      module.debug('Content loaded in background', tabPath);
                    }
                    settings.onFirstLoad.call($tab[0], tabPath, parameterArray,
                        historyEvent);
                    settings.onLoad.call($tab[0], tabPath, parameterArray,
                        historyEvent);

                    if (settings.loadOnce) {
                      module.cache.add(fullTabPath, true);
                    }
                    else if (typeof settings.cacheType == 'string'
                        && settings.cacheType.toLowerCase() == 'dom'
                        && $tab.children().length > 0) {
                      setTimeout(function () {
                        var
                            $clone = $tab.children().clone(true)
                        ;
                        $clone = $clone.not('script');
                        module.cache.add(fullTabPath, $clone);
                      }, 0);
                    }
                    else {
                      module.cache.add(fullTabPath, $tab.html());
                    }
                  },
                  urlData: {
                    tab: fullTabPath
                  }
                },
                request = $tab.api('get request') || false,
                existingRequest = ( request && request.state() === 'pending' ),
                requestSettings,
                cachedContent
            ;

            fullTabPath = fullTabPath || tabPath;
            cachedContent = module.cache.read(fullTabPath);

            if (settings.cache && cachedContent) {
              module.activate.tab(tabPath);
              module.debug('Adding cached content', fullTabPath);
              if (!settings.loadOnce) {
                if (settings.evaluateScripts == 'once') {
                  module.update.content(tabPath, cachedContent, false);
                }
                else {
                  module.update.content(tabPath, cachedContent);
                }
              }
              settings.onLoad.call($tab[0], tabPath, parameterArray,
                  historyEvent);
            }
            else if (existingRequest) {
              module.set.loading(tabPath);
              module.debug('Content is already loading', fullTabPath);
            }
            else if ($.api !== undefined) {
              requestSettings = $.extend(true, {}, settings.apiSettings,
                  apiSettings);
              module.debug('Retrieving remote content', fullTabPath,
                  requestSettings);
              module.set.loading(tabPath);
              $tab.api(requestSettings);
            }
            else {
              module.error(error.api);
            }
          }
        },

        activate: {
          all: function (tabPath) {
            module.activate.tab(tabPath);
            module.activate.navigation(tabPath);
          },
          tab: function (tabPath) {
            var
                $tab = module.get.tabElement(tabPath),
                $deactiveTabs = (settings.deactivate == 'siblings')
                    ? $tab.siblings($tabs)
                    : $tabs.not($tab),
                isActive = $tab.hasClass(className.active)
            ;
            module.verbose('Showing tab content for', $tab);
            if (!isActive) {
              $tab
              .addClass(className.active)
              ;
              $deactiveTabs
              .removeClass(className.active + ' ' + className.loading)
              ;
              if ($tab.length > 0) {
                settings.onVisible.call($tab[0], tabPath);
              }
            }
          },
          navigation: function (tabPath) {
            var
                $navigation = module.get.navElement(tabPath),
                $deactiveNavigation = (settings.deactivate == 'siblings')
                    ? $navigation.siblings($allModules)
                    : $allModules.not($navigation),
                isActive = $navigation.hasClass(className.active)
            ;
            module.verbose('Activating tab navigation for', $navigation,
                tabPath);
            if (!isActive) {
              $navigation
              .addClass(className.active)
              ;
              $deactiveNavigation
              .removeClass(className.active + ' ' + className.loading)
              ;
            }
          }
        },

        deactivate: {
          all: function () {
            module.deactivate.navigation();
            module.deactivate.tabs();
          },
          navigation: function () {
            $allModules
            .removeClass(className.active)
            ;
          },
          tabs: function () {
            $tabs
            .removeClass(className.active + ' ' + className.loading)
            ;
          }
        },

        is: {
          tab: function (tabName) {
            return (tabName !== undefined)
                ? ( module.get.tabElement(tabName).length > 0 )
                : false
                ;
          }
        },

        get: {
          initialPath: function () {
            return $allModules.eq(0).data(metadata.tab) || $tabs.eq(0).data(
                    metadata.tab);
          },
          path: function () {
            return $.address.value();
          },
          // adds default tabs to tab path
          defaultPathArray: function (tabPath) {
            return module.utilities.pathToArray(
                module.get.defaultPath(tabPath));
          },
          defaultPath: function (tabPath) {
            var
                $defaultNav = $allModules.filter(
                    '[data-' + metadata.tab + '^="' + tabPath + '/"]').eq(0),
                defaultTab = $defaultNav.data(metadata.tab) || false
            ;
            if (defaultTab) {
              module.debug('Found default tab', defaultTab);
              if (recursionDepth < settings.maxDepth) {
                recursionDepth++;
                return module.get.defaultPath(defaultTab);
              }
              module.error(error.recursion);
            }
            else {
              module.debug('No default tabs found for', tabPath, $tabs);
            }
            recursionDepth = 0;
            return tabPath;
          },
          navElement: function (tabPath) {
            tabPath = tabPath || activeTabPath;
            return $allModules.filter(
                '[data-' + metadata.tab + '="' + tabPath + '"]');
          },
          tabElement: function (tabPath) {
            var
                $fullPathTab,
                $simplePathTab,
                tabPathArray,
                lastTab
            ;
            tabPath = tabPath || activeTabPath;
            tabPathArray = module.utilities.pathToArray(tabPath);
            lastTab = module.utilities.last(tabPathArray);
            $fullPathTab = $tabs.filter(
                '[data-' + metadata.tab + '="' + tabPath + '"]');
            $simplePathTab = $tabs.filter(
                '[data-' + metadata.tab + '="' + lastTab + '"]');
            return ($fullPathTab.length > 0)
                ? $fullPathTab
                : $simplePathTab
                ;
          },
          tab: function () {
            return activeTabPath;
          }
        },

        utilities: {
          filterArray: function (keepArray, removeArray) {
            return $.grep(keepArray, function (keepValue) {
              return ( $.inArray(keepValue, removeArray) == -1);
            });
          },
          last: function (array) {
            return $.isArray(array)
                ? array[array.length - 1]
                : false
                ;
          },
          pathToArray: function (pathName) {
            if (pathName === undefined) {
              pathName = activeTabPath;
            }
            return typeof pathName == 'string'
                ? pathName.split('/')
                : [pathName]
                ;
          },
          arrayToPath: function (pathArray) {
            return $.isArray(pathArray)
                ? pathArray.join('/')
                : false
                ;
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };
      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;
    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;

  };

// shortcut for tabbed content with no defined navigation
  $.tab = function () {
    $(window).tab.apply(this, arguments);
  };

  $.fn.tab.settings = {

    name: 'Tab',
    namespace: 'tab',

    silent: false,
    debug: false,
    verbose: false,
    performance: true,

    auto: false,      // uses pjax style endpoints fetching content from same url with remote-content headers
    history: false,      // use browser history
    historyType: 'hash',     // #/ or html5 state
    path: false,      // base path of url

    context: false,      // specify a context that tabs must appear inside
    childrenOnly: false,      // use only tabs that are children of context
    maxDepth: 25,         // max depth a tab can be nested

    deactivate: 'siblings', // whether tabs should deactivate sibling menu elements or all elements initialized together

    alwaysRefresh: false,      // load tab content new every tab click
    cache: true,       // cache the content requests to pull locally
    loadOnce: false,      // Whether tab data should only be loaded once when using remote content
    cacheType: 'response', // Whether to cache exact response, or to html cache contents after scripts execute
    ignoreFirstLoad: false,      // don't load remote content on first load

    apiSettings: false,      // settings for api call
    evaluateScripts: 'once',     // whether inline scripts should be parsed (true/false/once). Once will not re-evaluate on cached content

    onFirstLoad: function (tabPath, parameterArray, historyEvent) {
    }, // called first time loaded
    onLoad: function (tabPath, parameterArray, historyEvent) {
    }, // called on every load
    onVisible: function (tabPath, parameterArray, historyEvent) {
    }, // called every time tab visible
    onRequest: function (tabPath, parameterArray, historyEvent) {
    }, // called ever time a tab beings loading remote content

    templates: {
      determineTitle: function (tabArray) {
      } // returns page title for path
    },

    error: {
      api: 'You attempted to load content without API module',
      method: 'The method you called is not defined',
      missingTab: 'Activated tab cannot be found. Tabs are case-sensitive.',
      noContent: 'The tab you specified is missing a content url.',
      path: 'History enabled, but no path was specified',
      recursion: 'Max recursive depth reached',
      legacyInit: 'onTabInit has been renamed to onFirstLoad in 2.0, please adjust your code.',
      legacyLoad: 'onTabLoad has been renamed to onLoad in 2.0. Please adjust your code',
      state: 'History requires Asual\'s Address library <https://github.com/asual/jquery-address>'
    },

    metadata: {
      tab: 'tab',
      loaded: 'loaded',
      promise: 'promise'
    },

    className: {
      loading: 'loading',
      active: 'active'
    },

    selector: {
      tabs: '.ui.tab',
      ui: '.ui'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Transition
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.transition = function () {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        moduleArguments = arguments,
        query = moduleArguments[0],
        queryArguments = [].slice.call(arguments, 1),
        methodInvoked = (typeof query === 'string'),

        requestAnimationFrame = window.requestAnimationFrame
            || window.mozRequestAnimationFrame
            || window.webkitRequestAnimationFrame
            || window.msRequestAnimationFrame
            || function (callback) {
              setTimeout(callback, 0);
            },

        returnedValue
    ;
    $allModules
    .each(function (index) {
      var
          $module = $(this),
          element = this,

          // set at run time
          settings,
          instance,

          error,
          className,
          metadata,
          animationEnd,
          animationName,

          namespace,
          moduleNamespace,
          eventNamespace,
          module
      ;

      module = {

        initialize: function () {

          // get full settings
          settings = module.get.settings.apply(element, moduleArguments);

          // shorthand
          className = settings.className;
          error = settings.error;
          metadata = settings.metadata;

          // define namespace
          eventNamespace = '.' + settings.namespace;
          moduleNamespace = 'module-' + settings.namespace;
          instance = $module.data(moduleNamespace) || module;

          // get vendor specific events
          animationEnd = module.get.animationEndEvent();

          if (methodInvoked) {
            methodInvoked = module.invoke(query);
          }

          // method not invoked, lets run an animation
          if (methodInvoked === false) {
            module.verbose('Converted arguments into settings object',
                settings);
            if (settings.interval) {
              module.delay(settings.animate);
            }
            else {
              module.animate();
            }
            module.instantiate();
          }
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, instance)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous module for', element);
          $module
          .removeData(moduleNamespace)
          ;
        },

        refresh: function () {
          module.verbose('Refreshing display type on next animation');
          delete module.displayType;
        },

        forceRepaint: function () {
          module.verbose('Forcing element repaint');
          var
              $parentElement = $module.parent(),
              $nextElement = $module.next()
          ;
          if ($nextElement.length === 0) {
            $module.detach().appendTo($parentElement);
          }
          else {
            $module.detach().insertBefore($nextElement);
          }
        },

        repaint: function () {
          module.verbose('Repainting element');
          var
              fakeAssignment = element.offsetWidth
          ;
        },

        delay: function (interval) {
          var
              direction = module.get.animationDirection(),
              shouldReverse,
              delay
          ;
          if (!direction) {
            direction = module.can.transition()
                ? module.get.direction()
                : 'static'
            ;
          }
          interval = (interval !== undefined)
              ? interval
              : settings.interval
          ;
          shouldReverse = (settings.reverse == 'auto' && direction
          == className.outward);
          delay = (shouldReverse || settings.reverse == true)
              ? ($allModules.length - index) * settings.interval
              : index * settings.interval
          ;
          module.debug('Delaying animation by', delay);
          setTimeout(module.animate, delay);
        },

        animate: function (overrideSettings) {
          settings = overrideSettings || settings;
          if (!module.is.supported()) {
            module.error(error.support);
            return false;
          }
          module.debug('Preparing animation', settings.animation);
          if (module.is.animating()) {
            if (settings.queue) {
              if (!settings.allowRepeats && module.has.direction()
                  && module.is.occurring() && module.queuing !== true) {
                module.debug(
                    'Animation is currently occurring, preventing queueing same animation',
                    settings.animation);
              }
              else {
                module.queue(settings.animation);
              }
              return false;
            }
            else if (!settings.allowRepeats && module.is.occurring()) {
              module.debug(
                  'Animation is already occurring, will not execute repeated animation',
                  settings.animation);
              return false;
            }
            else {
              module.debug('New animation started, completing previous early',
                  settings.animation);
              instance.complete();
            }
          }
          if (module.can.animate()) {
            module.set.animating(settings.animation);
          }
          else {
            module.error(error.noAnimation, settings.animation, element);
          }
        },

        reset: function () {
          module.debug('Resetting animation to beginning conditions');
          module.remove.animationCallbacks();
          module.restore.conditions();
          module.remove.animating();
        },

        queue: function (animation) {
          module.debug('Queueing animation of', animation);
          module.queuing = true;
          $module
          .one(animationEnd + '.queue' + eventNamespace, function () {
            module.queuing = false;
            module.repaint();
            module.animate.apply(this, settings);
          })
          ;
        },

        complete: function (event) {
          module.debug('Animation complete', settings.animation);
          module.remove.completeCallback();
          module.remove.failSafe();
          if (!module.is.looping()) {
            if (module.is.outward()) {
              module.verbose('Animation is outward, hiding element');
              module.restore.conditions();
              module.hide();
            }
            else if (module.is.inward()) {
              module.verbose('Animation is outward, showing element');
              module.restore.conditions();
              module.show();
            }
            else {
              module.verbose('Static animation completed');
              module.restore.conditions();
              settings.onComplete.call(element);
            }
          }
        },

        force: {
          visible: function () {
            var
                style = $module.attr('style'),
                userStyle = module.get.userStyle(),
                displayType = module.get.displayType(),
                overrideStyle = userStyle + 'display: ' + displayType
                    + ' !important;',
                currentDisplay = $module.css('display'),
                emptyStyle = (style === undefined || style === '')
            ;
            if (currentDisplay !== displayType) {
              module.verbose('Overriding default display to show element',
                  displayType);
              $module
              .attr('style', overrideStyle)
              ;
            }
            else if (emptyStyle) {
              $module.removeAttr('style');
            }
          },
          hidden: function () {
            var
                style = $module.attr('style'),
                currentDisplay = $module.css('display'),
                emptyStyle = (style === undefined || style === '')
            ;
            if (currentDisplay !== 'none' && !module.is.hidden()) {
              module.verbose('Overriding default display to hide element');
              $module
              .css('display', 'none')
              ;
            }
            else if (emptyStyle) {
              $module
              .removeAttr('style')
              ;
            }
          }
        },

        has: {
          direction: function (animation) {
            var
                hasDirection = false
            ;
            animation = animation || settings.animation;
            if (typeof animation === 'string') {
              animation = animation.split(' ');
              $.each(animation, function (index, word) {
                if (word === className.inward || word === className.outward) {
                  hasDirection = true;
                }
              });
            }
            return hasDirection;
          },
          inlineDisplay: function () {
            var
                style = $module.attr('style') || ''
            ;
            return $.isArray(style.match(/display.*?;/, ''));
          }
        },

        set: {
          animating: function (animation) {
            var
                animationClass,
                direction
            ;
            // remove previous callbacks
            module.remove.completeCallback();

            // determine exact animation
            animation = animation || settings.animation;
            animationClass = module.get.animationClass(animation);

            // save animation class in cache to restore class names
            module.save.animation(animationClass);

            // override display if necessary so animation appears visibly
            module.force.visible();

            module.remove.hidden();
            module.remove.direction();

            module.start.animation(animationClass);

          },
          duration: function (animationName, duration) {
            duration = duration || settings.duration;
            duration = (typeof duration == 'number')
                ? duration + 'ms'
                : duration
            ;
            if (duration || duration === 0) {
              module.verbose('Setting animation duration', duration);
              $module
              .css({
                'animation-duration': duration
              })
              ;
            }
          },
          direction: function (direction) {
            direction = direction || module.get.direction();
            if (direction == className.inward) {
              module.set.inward();
            }
            else {
              module.set.outward();
            }
          },
          looping: function () {
            module.debug('Transition set to loop');
            $module
            .addClass(className.looping)
            ;
          },
          hidden: function () {
            $module
            .addClass(className.transition)
            .addClass(className.hidden)
            ;
          },
          inward: function () {
            module.debug('Setting direction to inward');
            $module
            .removeClass(className.outward)
            .addClass(className.inward)
            ;
          },
          outward: function () {
            module.debug('Setting direction to outward');
            $module
            .removeClass(className.inward)
            .addClass(className.outward)
            ;
          },
          visible: function () {
            $module
            .addClass(className.transition)
            .addClass(className.visible)
            ;
          }
        },

        start: {
          animation: function (animationClass) {
            animationClass = animationClass || module.get.animationClass();
            module.debug('Starting tween', animationClass);
            $module
            .addClass(animationClass)
            .one(animationEnd + '.complete' + eventNamespace, module.complete)
            ;
            if (settings.useFailSafe) {
              module.add.failSafe();
            }
            module.set.duration(settings.duration);
            settings.onStart.call(element);
          }
        },

        save: {
          animation: function (animation) {
            if (!module.cache) {
              module.cache = {};
            }
            module.cache.animation = animation;
          },
          displayType: function (displayType) {
            if (displayType !== 'none') {
              $module.data(metadata.displayType, displayType);
            }
          },
          transitionExists: function (animation, exists) {
            $.fn.transition.exists[animation] = exists;
            module.verbose('Saving existence of transition', animation, exists);
          }
        },

        restore: {
          conditions: function () {
            var
                animation = module.get.currentAnimation()
            ;
            if (animation) {
              $module
              .removeClass(animation)
              ;
              module.verbose('Removing animation class', module.cache);
            }
            module.remove.duration();
          }
        },

        add: {
          failSafe: function () {
            var
                duration = module.get.duration()
            ;
            module.timer = setTimeout(function () {
              $module.triggerHandler(animationEnd);
            }, duration + settings.failSafeDelay);
            module.verbose('Adding fail safe timer', module.timer);
          }
        },

        remove: {
          animating: function () {
            $module.removeClass(className.animating);
          },
          animationCallbacks: function () {
            module.remove.queueCallback();
            module.remove.completeCallback();
          },
          queueCallback: function () {
            $module.off('.queue' + eventNamespace);
          },
          completeCallback: function () {
            $module.off('.complete' + eventNamespace);
          },
          display: function () {
            $module.css('display', '');
          },
          direction: function () {
            $module
            .removeClass(className.inward)
            .removeClass(className.outward)
            ;
          },
          duration: function () {
            $module
            .css('animation-duration', '')
            ;
          },
          failSafe: function () {
            module.verbose('Removing fail safe timer', module.timer);
            if (module.timer) {
              clearTimeout(module.timer);
            }
          },
          hidden: function () {
            $module.removeClass(className.hidden);
          },
          visible: function () {
            $module.removeClass(className.visible);
          },
          looping: function () {
            module.debug('Transitions are no longer looping');
            if (module.is.looping()) {
              module.reset();
              $module
              .removeClass(className.looping)
              ;
            }
          },
          transition: function () {
            $module
            .removeClass(className.visible)
            .removeClass(className.hidden)
            ;
          }
        },
        get: {
          settings: function (animation, duration, onComplete) {
            // single settings object
            if (typeof animation == 'object') {
              return $.extend(true, {}, $.fn.transition.settings, animation);
            }
            // all arguments provided
            else if (typeof onComplete == 'function') {
              return $.extend({}, $.fn.transition.settings, {
                animation: animation,
                onComplete: onComplete,
                duration: duration
              });
            }
            // only duration provided
            else if (typeof duration == 'string' || typeof duration
                == 'number') {
              return $.extend({}, $.fn.transition.settings, {
                animation: animation,
                duration: duration
              });
            }
            // duration is actually settings object
            else if (typeof duration == 'object') {
              return $.extend({}, $.fn.transition.settings, duration, {
                animation: animation
              });
            }
            // duration is actually callback
            else if (typeof duration == 'function') {
              return $.extend({}, $.fn.transition.settings, {
                animation: animation,
                onComplete: duration
              });
            }
            // only animation provided
            else {
              return $.extend({}, $.fn.transition.settings, {
                animation: animation
              });
            }
          },
          animationClass: function (animation) {
            var
                animationClass = animation || settings.animation,
                directionClass = (module.can.transition()
                && !module.has.direction())
                    ? module.get.direction() + ' '
                    : ''
            ;
            return className.animating + ' '
                + className.transition + ' '
                + directionClass
                + animationClass
                ;
          },
          currentAnimation: function () {
            return (module.cache && module.cache.animation !== undefined)
                ? module.cache.animation
                : false
                ;
          },
          currentDirection: function () {
            return module.is.inward()
                ? className.inward
                : className.outward
                ;
          },
          direction: function () {
            return module.is.hidden() || !module.is.visible()
                ? className.inward
                : className.outward
                ;
          },
          animationDirection: function (animation) {
            var
                direction
            ;
            animation = animation || settings.animation;
            if (typeof animation === 'string') {
              animation = animation.split(' ');
              // search animation name for out/in class
              $.each(animation, function (index, word) {
                if (word === className.inward) {
                  direction = className.inward;
                }
                else if (word === className.outward) {
                  direction = className.outward;
                }
              });
            }
            // return found direction
            if (direction) {
              return direction;
            }
            return false;
          },
          duration: function (duration) {
            duration = duration || settings.duration;
            if (duration === false) {
              duration = $module.css('animation-duration') || 0;
            }
            return (typeof duration === 'string')
                ? (duration.indexOf('ms') > -1)
                    ? parseFloat(duration)
                    : parseFloat(duration) * 1000
                : duration
                ;
          },
          displayType: function (shouldDetermine) {
            shouldDetermine = (shouldDetermine !== undefined)
                ? shouldDetermine
                : true
            ;
            if (settings.displayType) {
              return settings.displayType;
            }
            if (shouldDetermine && $module.data(metadata.displayType)
                === undefined) {
              // create fake element to determine display state
              module.can.transition(true);
            }
            return $module.data(metadata.displayType);
          },
          userStyle: function (style) {
            style = style || $module.attr('style') || '';
            return style.replace(/display.*?;/, '');
          },
          transitionExists: function (animation) {
            return $.fn.transition.exists[animation];
          },
          animationStartEvent: function () {
            var
                element = document.createElement('div'),
                animations = {
                  'animation': 'animationstart',
                  'OAnimation': 'oAnimationStart',
                  'MozAnimation': 'mozAnimationStart',
                  'WebkitAnimation': 'webkitAnimationStart'
                },
                animation
            ;
            for (animation in animations) {
              if (element.style[animation] !== undefined) {
                return animations[animation];
              }
            }
            return false;
          },
          animationEndEvent: function () {
            var
                element = document.createElement('div'),
                animations = {
                  'animation': 'animationend',
                  'OAnimation': 'oAnimationEnd',
                  'MozAnimation': 'mozAnimationEnd',
                  'WebkitAnimation': 'webkitAnimationEnd'
                },
                animation
            ;
            for (animation in animations) {
              if (element.style[animation] !== undefined) {
                return animations[animation];
              }
            }
            return false;
          }

        },

        can: {
          transition: function (forced) {
            var
                animation = settings.animation,
                transitionExists = module.get.transitionExists(animation),
                displayType = module.get.displayType(false),
                elementClass,
                tagName,
                $clone,
                currentAnimation,
                inAnimation,
                directionExists
            ;
            if (transitionExists === undefined || forced) {
              module.verbose('Determining whether animation exists');
              elementClass = $module.attr('class');
              tagName = $module.prop('tagName');

              $clone = $('<' + tagName + ' />').addClass(
                  elementClass).insertAfter($module);
              currentAnimation = $clone
              .addClass(animation)
              .removeClass(className.inward)
              .removeClass(className.outward)
              .addClass(className.animating)
              .addClass(className.transition)
              .css('animationName')
              ;
              inAnimation = $clone
              .addClass(className.inward)
              .css('animationName')
              ;
              if (!displayType) {
                displayType = $clone
                .attr('class', elementClass)
                .removeAttr('style')
                .removeClass(className.hidden)
                .removeClass(className.visible)
                .show()
                .css('display')
                ;
                module.verbose('Determining final display state', displayType);
                module.save.displayType(displayType);
              }

              $clone.remove();
              if (currentAnimation != inAnimation) {
                module.debug('Direction exists for animation', animation);
                directionExists = true;
              }
              else if (currentAnimation == 'none' || !currentAnimation) {
                module.debug('No animation defined in css', animation);
                return;
              }
              else {
                module.debug('Static animation found', animation, displayType);
                directionExists = false;
              }
              module.save.transitionExists(animation, directionExists);
            }
            return (transitionExists !== undefined)
                ? transitionExists
                : directionExists
                ;
          },
          animate: function () {
            // can transition does not return a value if animation does not exist
            return (module.can.transition() !== undefined);
          }
        },

        is: {
          animating: function () {
            return $module.hasClass(className.animating);
          },
          inward: function () {
            return $module.hasClass(className.inward);
          },
          outward: function () {
            return $module.hasClass(className.outward);
          },
          looping: function () {
            return $module.hasClass(className.looping);
          },
          occurring: function (animation) {
            animation = animation || settings.animation;
            animation = '.' + animation.replace(' ', '.');
            return ( $module.filter(animation).length > 0 );
          },
          visible: function () {
            return $module.is(':visible');
          },
          hidden: function () {
            return $module.css('visibility') === 'hidden';
          },
          supported: function () {
            return (animationEnd !== false);
          }
        },

        hide: function () {
          module.verbose('Hiding element');
          if (module.is.animating()) {
            module.reset();
          }
          element.blur(); // IE will trigger focus change if element is not blurred before hiding
          module.remove.display();
          module.remove.visible();
          module.set.hidden();
          module.force.hidden();
          settings.onHide.call(element);
          settings.onComplete.call(element);
          // module.repaint();
        },

        show: function (display) {
          module.verbose('Showing element', display);
          module.remove.hidden();
          module.set.visible();
          module.force.visible();
          settings.onShow.call(element);
          settings.onComplete.call(element);
          // module.repaint();
        },

        toggle: function () {
          if (module.is.visible()) {
            module.hide();
          }
          else {
            module.show();
          }
        },

        stop: function () {
          module.debug('Stopping current animation');
          $module.triggerHandler(animationEnd);
        },

        stopAll: function () {
          module.debug('Stopping all animation');
          module.remove.queueCallback();
          $module.triggerHandler(animationEnd);
        },

        clear: {
          queue: function () {
            module.debug('Clearing animation queue');
            module.remove.queueCallback();
          }
        },

        enable: function () {
          module.verbose('Starting animation');
          $module.removeClass(className.disabled);
        },

        disable: function () {
          module.debug('Stopping animation');
          $module.addClass(className.disabled);
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ($allModules.length > 1) {
              title += ' ' + '(' + $allModules.length + ')';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        // modified for transition to return invoke success
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }

          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return (found !== undefined)
              ? found
              : false
              ;
        }
      };
      module.initialize();
    })
    ;
    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

// Records if CSS transition is available
  $.fn.transition.exists = {};

  $.fn.transition.settings = {

    // module info
    name: 'Transition',

    // hide all output from this component regardless of other settings
    silent: false,

    // debug content outputted to console
    debug: false,

    // verbose debug output
    verbose: false,

    // performance data output
    performance: true,

    // event namespace
    namespace: 'transition',

    // delay between animations in group
    interval: 0,

    // whether group animations should be reversed
    reverse: 'auto',

    // animation callback event
    onStart: function () {
    },
    onComplete: function () {
    },
    onShow: function () {
    },
    onHide: function () {
    },

    // whether timeout should be used to ensure callback fires in cases animationend does not
    useFailSafe: true,

    // delay in ms for fail safe
    failSafeDelay: 100,

    // whether EXACT animation can occur twice in a row
    allowRepeats: false,

    // Override final display type on visible
    displayType: false,

    // animation duration
    animation: 'fade',
    duration: false,

    // new animations will occur after previous ones
    queue: true,

    metadata: {
      displayType: 'display'
    },

    className: {
      animating: 'animating',
      disabled: 'disabled',
      hidden: 'hidden',
      inward: 'in',
      loading: 'loading',
      looping: 'looping',
      outward: 'out',
      transition: 'transition',
      visible: 'visible'
    },

    // possible errors
    error: {
      noAnimation: 'Element is no longer attached to DOM. Unable to animate.  Use silent setting to surpress this warning in production.',
      repeated: 'That animation is already occurring, cancelling repeated animation',
      method: 'The method you called is not defined',
      support: 'This browser does not support CSS animations'
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - API
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  var
      window = (typeof window != 'undefined' && window.Math == Math)
          ? window
          : (typeof self != 'undefined' && self.Math == Math)
              ? self
              : Function('return this')()
  ;

  $.api = $.fn.api = function (parameters) {

    var
        // use window context if none specified
        $allModules = $.isFunction(this)
            ? $(window)
            : $(this),
        moduleSelector = $allModules.selector || '',
        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        returnedValue
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.api.settings, parameters)
              : $.extend({}, $.fn.api.settings),

          // internal aliases
          namespace = settings.namespace,
          metadata = settings.metadata,
          selector = settings.selector,
          error = settings.error,
          className = settings.className,

          // define namespaces for modules
          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          // element that creates request
          $module = $(this),
          $form = $module.closest(selector.form),

          // context used for state
          $context = (settings.stateContext)
              ? $(settings.stateContext)
              : $module,

          // request details
          ajaxSettings,
          requestSettings,
          url,
          data,
          requestStartTime,

          // standard module
          element = this,
          context = $context[0],
          instance = $module.data(moduleNamespace),
          module
      ;

      module = {

        initialize: function () {
          if (!methodInvoked) {
            module.bind.events();
          }
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, instance)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous module for', element);
          $module
          .removeData(moduleNamespace)
          .off(eventNamespace)
          ;
        },

        bind: {
          events: function () {
            var
                triggerEvent = module.get.event()
            ;
            if (triggerEvent) {
              module.verbose('Attaching API events to element', triggerEvent);
              $module
              .on(triggerEvent + eventNamespace, module.event.trigger)
              ;
            }
            else if (settings.on == 'now') {
              module.debug('Querying API endpoint immediately');
              module.query();
            }
          }
        },

        decode: {
          json: function (response) {
            if (response !== undefined && typeof response == 'string') {
              try {
                response = JSON.parse(response);
              }
              catch (e) {
                // isnt json string
              }
            }
            return response;
          }
        },

        read: {
          cachedResponse: function (url) {
            var
                response
            ;
            if (window.Storage === undefined) {
              module.error(error.noStorage);
              return;
            }
            response = sessionStorage.getItem(url);
            module.debug('Using cached response', url, response);
            response = module.decode.json(response);
            return response;
          }
        },
        write: {
          cachedResponse: function (url, response) {
            if (response && response === '') {
              module.debug('Response empty, not caching', response);
              return;
            }
            if (window.Storage === undefined) {
              module.error(error.noStorage);
              return;
            }
            if ($.isPlainObject(response)) {
              response = JSON.stringify(response);
            }
            sessionStorage.setItem(url, response);
            module.verbose('Storing cached response for url', url, response);
          }
        },

        query: function () {

          if (module.is.disabled()) {
            module.debug('Element is disabled API request aborted');
            return;
          }

          if (module.is.loading()) {
            if (settings.interruptRequests) {
              module.debug('Interrupting previous request');
              module.abort();
            }
            else {
              module.debug(
                  'Cancelling request, previous request is still pending');
              return;
            }
          }

          // pass element metadata to url (value, text)
          if (settings.defaultData) {
            $.extend(true, settings.urlData, module.get.defaultData());
          }

          // Add form content
          if (settings.serializeForm) {
            settings.data = module.add.formData(settings.data);
          }

          // call beforesend and get any settings changes
          requestSettings = module.get.settings();

          // check if before send cancelled request
          if (requestSettings === false) {
            module.cancelled = true;
            module.error(error.beforeSend);
            return;
          }
          else {
            module.cancelled = false;
          }

          // get url
          url = module.get.templatedURL();

          if (!url && !module.is.mocked()) {
            module.error(error.missingURL);
            return;
          }

          // replace variables
          url = module.add.urlData(url);
          // missing url parameters
          if (!url && !module.is.mocked()) {
            return;
          }

          requestSettings.url = settings.base + url;

          // look for jQuery ajax parameters in settings
          ajaxSettings = $.extend(true, {}, settings, {
            type: settings.method || settings.type,
            data: data,
            url: settings.base + url,
            beforeSend: settings.beforeXHR,
            success: function () {
            },
            failure: function () {
            },
            complete: function () {
            }
          });

          module.debug('Querying URL', ajaxSettings.url);
          module.verbose('Using AJAX settings', ajaxSettings);
          if (settings.cache === 'local' && module.read.cachedResponse(url)) {
            module.debug('Response returned from local cache');
            module.request = module.create.request();
            module.request.resolveWith(context,
                [module.read.cachedResponse(url)]);
            return;
          }

          if (!settings.throttle) {
            module.debug('Sending request', data, ajaxSettings.method);
            module.send.request();
          }
          else {
            if (!settings.throttleFirstRequest && !module.timer) {
              module.debug('Sending request', data, ajaxSettings.method);
              module.send.request();
              module.timer = setTimeout(function () {
              }, settings.throttle);
            }
            else {
              module.debug('Throttling request', settings.throttle);
              clearTimeout(module.timer);
              module.timer = setTimeout(function () {
                if (module.timer) {
                  delete module.timer;
                }
                module.debug('Sending throttled request', data,
                    ajaxSettings.method);
                module.send.request();
              }, settings.throttle);
            }
          }

        },

        should: {
          removeError: function () {
            return ( settings.hideError === true || (settings.hideError
            === 'auto' && !module.is.form()) );
          }
        },

        is: {
          disabled: function () {
            return ($module.filter(selector.disabled).length > 0);
          },
          expectingJSON: function () {
            return settings.dataType === 'json' || settings.dataType
                === 'jsonp';
          },
          form: function () {
            return $module.is('form') || $context.is('form');
          },
          mocked: function () {
            return (settings.mockResponse || settings.mockResponseAsync
            || settings.response || settings.responseAsync);
          },
          input: function () {
            return $module.is('input');
          },
          loading: function () {
            return (module.request)
                ? (module.request.state() == 'pending')
                : false
                ;
          },
          abortedRequest: function (xhr) {
            if (xhr && xhr.readyState !== undefined && xhr.readyState === 0) {
              module.verbose('XHR request determined to be aborted');
              return true;
            }
            else {
              module.verbose('XHR request was not aborted');
              return false;
            }
          },
          validResponse: function (response) {
            if ((!module.is.expectingJSON()) || !$.isFunction(
                    settings.successTest)) {
              module.verbose('Response is not JSON, skipping validation',
                  settings.successTest, response);
              return true;
            }
            module.debug('Checking JSON returned success', settings.successTest,
                response);
            if (settings.successTest(response)) {
              module.debug('Response passed success test', response);
              return true;
            }
            else {
              module.debug('Response failed success test', response);
              return false;
            }
          }
        },

        was: {
          cancelled: function () {
            return (module.cancelled || false);
          },
          succesful: function () {
            return (module.request && module.request.state() == 'resolved');
          },
          failure: function () {
            return (module.request && module.request.state() == 'rejected');
          },
          complete: function () {
            return (module.request && (module.request.state() == 'resolved'
            || module.request.state() == 'rejected') );
          }
        },

        add: {
          urlData: function (url, urlData) {
            var
                requiredVariables,
                optionalVariables
            ;
            if (url) {
              requiredVariables = url.match(settings.regExp.required);
              optionalVariables = url.match(settings.regExp.optional);
              urlData = urlData || settings.urlData;
              if (requiredVariables) {
                module.debug('Looking for required URL variables',
                    requiredVariables);
                $.each(requiredVariables, function (index, templatedString) {
                  var
                      // allow legacy {$var} style
                      variable = (templatedString.indexOf('$') !== -1)
                          ? templatedString.substr(2,
                              templatedString.length - 3)
                          : templatedString.substr(1,
                              templatedString.length - 2),
                      value = ($.isPlainObject(urlData) && urlData[variable]
                      !== undefined)
                          ? urlData[variable]
                          : ($module.data(variable) !== undefined)
                              ? $module.data(variable)
                              : ($context.data(variable) !== undefined)
                                  ? $context.data(variable)
                                  : urlData[variable]
                  ;
                  // remove value
                  if (value === undefined) {
                    module.error(error.requiredParameter, variable, url);
                    url = false;
                    return false;
                  }
                  else {
                    module.verbose('Found required variable', variable, value);
                    value = (settings.encodeParameters)
                        ? module.get.urlEncodedValue(value)
                        : value
                    ;
                    url = url.replace(templatedString, value);
                  }
                });
              }
              if (optionalVariables) {
                module.debug('Looking for optional URL variables',
                    requiredVariables);
                $.each(optionalVariables, function (index, templatedString) {
                  var
                      // allow legacy {/$var} style
                      variable = (templatedString.indexOf('$') !== -1)
                          ? templatedString.substr(3,
                              templatedString.length - 4)
                          : templatedString.substr(2,
                              templatedString.length - 3),
                      value = ($.isPlainObject(urlData) && urlData[variable]
                      !== undefined)
                          ? urlData[variable]
                          : ($module.data(variable) !== undefined)
                              ? $module.data(variable)
                              : ($context.data(variable) !== undefined)
                                  ? $context.data(variable)
                                  : urlData[variable]
                  ;
                  // optional replacement
                  if (value !== undefined) {
                    module.verbose('Optional variable Found', variable, value);
                    url = url.replace(templatedString, value);
                  }
                  else {
                    module.verbose('Optional variable not found', variable);
                    // remove preceding slash if set
                    if (url.indexOf('/' + templatedString) !== -1) {
                      url = url.replace('/' + templatedString, '');
                    }
                    else {
                      url = url.replace(templatedString, '');
                    }
                  }
                });
              }
            }
            return url;
          },
          formData: function (data) {
            var
                canSerialize = ($.fn.serializeObject !== undefined),
                formData = (canSerialize)
                    ? $form.serializeObject()
                    : $form.serialize(),
                hasOtherData
            ;
            data = data || settings.data;
            hasOtherData = $.isPlainObject(data);

            if (hasOtherData) {
              if (canSerialize) {
                module.debug('Extending existing data with form data', data,
                    formData);
                data = $.extend(true, {}, data, formData);
              }
              else {
                module.error(error.missingSerialize);
                module.debug('Cant extend data. Replacing data with form data',
                    data, formData);
                data = formData;
              }
            }
            else {
              module.debug('Adding form data', formData);
              data = formData;
            }
            return data;
          }
        },

        send: {
          request: function () {
            module.set.loading();
            module.request = module.create.request();
            if (module.is.mocked()) {
              module.mockedXHR = module.create.mockedXHR();
            }
            else {
              module.xhr = module.create.xhr();
            }
            settings.onRequest.call(context, module.request, module.xhr);
          }
        },

        event: {
          trigger: function (event) {
            module.query();
            if (event.type == 'submit' || event.type == 'click') {
              event.preventDefault();
            }
          },
          xhr: {
            always: function () {
              // nothing special
            },
            done: function (response, textStatus, xhr) {
              var
                  context = this,
                  elapsedTime = (new Date().getTime() - requestStartTime),
                  timeLeft = (settings.loadingDuration - elapsedTime),
                  translatedResponse = ( $.isFunction(settings.onResponse) )
                      ? module.is.expectingJSON()
                          ? settings.onResponse.call(context,
                              $.extend(true, {}, response))
                          : settings.onResponse.call(context, response)
                      : false
              ;
              timeLeft = (timeLeft > 0)
                  ? timeLeft
                  : 0
              ;
              if (translatedResponse) {
                module.debug('Modified API response in onResponse callback',
                    settings.onResponse, translatedResponse, response);
                response = translatedResponse;
              }
              if (timeLeft > 0) {
                module.debug(
                    'Response completed early delaying state change by',
                    timeLeft);
              }
              setTimeout(function () {
                if (module.is.validResponse(response)) {
                  module.request.resolveWith(context, [response, xhr]);
                }
                else {
                  module.request.rejectWith(context, [xhr, 'invalid']);
                }
              }, timeLeft);
            },
            fail: function (xhr, status, httpMessage) {
              var
                  context = this,
                  elapsedTime = (new Date().getTime() - requestStartTime),
                  timeLeft = (settings.loadingDuration - elapsedTime)
              ;
              timeLeft = (timeLeft > 0)
                  ? timeLeft
                  : 0
              ;
              if (timeLeft > 0) {
                module.debug(
                    'Response completed early delaying state change by',
                    timeLeft);
              }
              setTimeout(function () {
                if (module.is.abortedRequest(xhr)) {
                  module.request.rejectWith(context,
                      [xhr, 'aborted', httpMessage]);
                }
                else {
                  module.request.rejectWith(context,
                      [xhr, 'error', status, httpMessage]);
                }
              }, timeLeft);
            }
          },
          request: {
            done: function (response, xhr) {
              module.debug('Successful API Response', response);
              if (settings.cache === 'local' && url) {
                module.write.cachedResponse(url, response);
                module.debug('Saving server response locally', module.cache);
              }
              settings.onSuccess.call(context, response, $module, xhr);
            },
            complete: function (firstParameter, secondParameter) {
              var
                  xhr,
                  response
              ;
              // have to guess callback parameters based on request success
              if (module.was.succesful()) {
                response = firstParameter;
                xhr = secondParameter;
              }
              else {
                xhr = firstParameter;
                response = module.get.responseFromXHR(xhr);
              }
              module.remove.loading();
              settings.onComplete.call(context, response, $module, xhr);
            },
            fail: function (xhr, status, httpMessage) {
              var
                  // pull response from xhr if available
                  response = module.get.responseFromXHR(xhr),
                  errorMessage = module.get.errorFromRequest(response, status,
                      httpMessage)
              ;
              if (status == 'aborted') {
                module.debug(
                    'XHR Aborted (Most likely caused by page navigation or CORS Policy)',
                    status, httpMessage);
                settings.onAbort.call(context, status, $module, xhr);
                return true;
              }
              else if (status == 'invalid') {
                module.debug(
                    'JSON did not pass success test. A server-side error has most likely occurred',
                    response);
              }
              else if (status == 'error') {
                if (xhr !== undefined) {
                  module.debug('XHR produced a server error', status,
                      httpMessage);
                  // make sure we have an error to display to console
                  if (xhr.status != 200 && httpMessage !== undefined
                      && httpMessage !== '') {
                    module.error(error.statusMessage + httpMessage,
                        ajaxSettings.url);
                  }
                  settings.onError.call(context, errorMessage, $module, xhr);
                }
              }

              if (settings.errorDuration && status !== 'aborted') {
                module.debug('Adding error state');
                module.set.error();
                if (module.should.removeError()) {
                  setTimeout(module.remove.error, settings.errorDuration);
                }
              }
              module.debug('API Request failed', errorMessage, xhr);
              settings.onFailure.call(context, response, $module, xhr);
            }
          }
        },

        create: {

          request: function () {
            // api request promise
            return $.Deferred()
            .always(module.event.request.complete)
            .done(module.event.request.done)
            .fail(module.event.request.fail)
                ;
          },

          mockedXHR: function () {
            var
                // xhr does not simulate these properties of xhr but must return them
                textStatus = false,
                status = false,
                httpMessage = false,
                responder = settings.mockResponse || settings.response,
                asyncResponder = settings.mockResponseAsync
                    || settings.responseAsync,
                asyncCallback,
                response,
                mockedXHR
            ;

            mockedXHR = $.Deferred()
            .always(module.event.xhr.complete)
            .done(module.event.xhr.done)
            .fail(module.event.xhr.fail)
            ;

            if (responder) {
              if ($.isFunction(responder)) {
                module.debug('Using specified synchronous callback', responder);
                response = responder.call(context, requestSettings);
              }
              else {
                module.debug('Using settings specified response', responder);
                response = responder;
              }
              // simulating response
              mockedXHR.resolveWith(context,
                  [response, textStatus, {responseText: response}]);
            }
            else if ($.isFunction(asyncResponder)) {
              asyncCallback = function (response) {
                module.debug('Async callback returned response', response);

                if (response) {
                  mockedXHR.resolveWith(context,
                      [response, textStatus, {responseText: response}]);
                }
                else {
                  mockedXHR.rejectWith(context,
                      [{responseText: response}, status, httpMessage]);
                }
              };
              module.debug('Using specified async response callback',
                  asyncResponder);
              asyncResponder.call(context, requestSettings, asyncCallback);
            }
            return mockedXHR;
          },

          xhr: function () {
            var
                xhr
            ;
            // ajax request promise
            xhr = $.ajax(ajaxSettings)
            .always(module.event.xhr.always)
            .done(module.event.xhr.done)
            .fail(module.event.xhr.fail)
            ;
            module.verbose('Created server request', xhr, ajaxSettings);
            return xhr;
          }
        },

        set: {
          error: function () {
            module.verbose('Adding error state to element', $context);
            $context.addClass(className.error);
          },
          loading: function () {
            module.verbose('Adding loading state to element', $context);
            $context.addClass(className.loading);
            requestStartTime = new Date().getTime();
          }
        },

        remove: {
          error: function () {
            module.verbose('Removing error state from element', $context);
            $context.removeClass(className.error);
          },
          loading: function () {
            module.verbose('Removing loading state from element', $context);
            $context.removeClass(className.loading);
          }
        },

        get: {
          responseFromXHR: function (xhr) {
            return $.isPlainObject(xhr)
                ? (module.is.expectingJSON())
                    ? module.decode.json(xhr.responseText)
                    : xhr.responseText
                : false
                ;
          },
          errorFromRequest: function (response, status, httpMessage) {
            return ($.isPlainObject(response) && response.error !== undefined)
                ? response.error // use json error message
                : (settings.error[status] !== undefined) // use server error message
                    ? settings.error[status]
                    : httpMessage
                ;
          },
          request: function () {
            return module.request || false;
          },
          xhr: function () {
            return module.xhr || false;
          },
          settings: function () {
            var
                runSettings
            ;
            runSettings = settings.beforeSend.call(context, settings);
            if (runSettings) {
              if (runSettings.success !== undefined) {
                module.debug('Legacy success callback detected', runSettings);
                module.error(error.legacyParameters, runSettings.success);
                runSettings.onSuccess = runSettings.success;
              }
              if (runSettings.failure !== undefined) {
                module.debug('Legacy failure callback detected', runSettings);
                module.error(error.legacyParameters, runSettings.failure);
                runSettings.onFailure = runSettings.failure;
              }
              if (runSettings.complete !== undefined) {
                module.debug('Legacy complete callback detected', runSettings);
                module.error(error.legacyParameters, runSettings.complete);
                runSettings.onComplete = runSettings.complete;
              }
            }
            if (runSettings === undefined) {
              module.error(error.noReturnedValue);
            }
            if (runSettings === false) {
              return runSettings;
            }
            return (runSettings !== undefined)
                ? $.extend(true, {}, runSettings)
                : $.extend(true, {}, settings)
                ;
          },
          urlEncodedValue: function (value) {
            var
                decodedValue = window.decodeURIComponent(value),
                encodedValue = window.encodeURIComponent(value),
                alreadyEncoded = (decodedValue !== value)
            ;
            if (alreadyEncoded) {
              module.debug(
                  'URL value is already encoded, avoiding double encoding',
                  value);
              return value;
            }
            module.verbose('Encoding value using encodeURIComponent', value,
                encodedValue);
            return encodedValue;
          },
          defaultData: function () {
            var
                data = {}
            ;
            if (!$.isWindow(element)) {
              if (module.is.input()) {
                data.value = $module.val();
              }
              else if (module.is.form()) {

              }
              else {
                data.text = $module.text();
              }
            }
            return data;
          },
          event: function () {
            if ($.isWindow(element) || settings.on == 'now') {
              module.debug('API called without element, no events attached');
              return false;
            }
            else if (settings.on == 'auto') {
              if ($module.is('input')) {
                return (element.oninput !== undefined)
                    ? 'input'
                    : (element.onpropertychange !== undefined)
                        ? 'propertychange'
                        : 'keyup'
                    ;
              }
              else if ($module.is('form')) {
                return 'submit';
              }
              else {
                return 'click';
              }
            }
            else {
              return settings.on;
            }
          },
          templatedURL: function (action) {
            action = action || $module.data(metadata.action) || settings.action
                || false;
            url = $module.data(metadata.url) || settings.url || false;
            if (url) {
              module.debug('Using specified url', url);
              return url;
            }
            if (action) {
              module.debug('Looking up url for action', action, settings.api);
              if (settings.api[action] === undefined && !module.is.mocked()) {
                module.error(error.missingAction, settings.action,
                    settings.api);
                return;
              }
              url = settings.api[action];
            }
            else if (module.is.form()) {
              url = $module.attr('action') || $context.attr('action') || false;
              module.debug(
                  'No url or action specified, defaulting to form action', url);
            }
            return url;
          }
        },

        abort: function () {
          var
              xhr = module.get.xhr()
          ;
          if (xhr && xhr.state() !== 'resolved') {
            module.debug('Cancelling API request');
            xhr.abort();
          }
        },

        // reset state
        reset: function () {
          module.remove.error();
          module.remove.loading();
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                //'Element'        : element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.api.settings = {

    name: 'API',
    namespace: 'api',

    debug: false,
    verbose: false,
    performance: true,

    // object containing all templates endpoints
    api: {},

    // whether to cache responses
    cache: true,

    // whether new requests should abort previous requests
    interruptRequests: true,

    // event binding
    on: 'auto',

    // context for applying state classes
    stateContext: false,

    // duration for loading state
    loadingDuration: 0,

    // whether to hide errors after a period of time
    hideError: 'auto',

    // duration for error state
    errorDuration: 2000,

    // whether parameters should be encoded with encodeURIComponent
    encodeParameters: true,

    // API action to use
    action: false,

    // templated URL to use
    url: false,

    // base URL to apply to all endpoints
    base: '',

    // data that will
    urlData: {},

    // whether to add default data to url data
    defaultData: true,

    // whether to serialize closest form
    serializeForm: false,

    // how long to wait before request should occur
    throttle: 0,

    // whether to throttle first request or only repeated
    throttleFirstRequest: true,

    // standard ajax settings
    method: 'get',
    data: {},
    dataType: 'json',

    // mock response
    mockResponse: false,
    mockResponseAsync: false,

    // aliases for mock
    response: false,
    responseAsync: false,

    // callbacks before request
    beforeSend: function (settings) {
      return settings;
    },
    beforeXHR: function (xhr) {
    },
    onRequest: function (promise, xhr) {
    },

    // after request
    onResponse: false, // function(response) { },

    // response was successful, if JSON passed validation
    onSuccess: function (response, $module) {
    },

    // request finished without aborting
    onComplete: function (response, $module) {
    },

    // failed JSON success test
    onFailure: function (response, $module) {
    },

    // server error
    onError: function (errorMessage, $module) {
    },

    // request aborted
    onAbort: function (errorMessage, $module) {
    },

    successTest: false,

    // errors
    error: {
      beforeSend: 'The before send function has aborted the request',
      error: 'There was an error with your request',
      exitConditions: 'API Request Aborted. Exit conditions met',
      JSONParse: 'JSON could not be parsed during error handling',
      legacyParameters: 'You are using legacy API success callback names',
      method: 'The method you called is not defined',
      missingAction: 'API action used but no url was defined',
      missingSerialize: 'jquery-serialize-object is required to add form data to an existing data object',
      missingURL: 'No URL specified for api event',
      noReturnedValue: 'The beforeSend callback must return a settings object, beforeSend ignored.',
      noStorage: 'Caching responses locally requires session storage',
      parseError: 'There was an error parsing your request',
      requiredParameter: 'Missing a required URL parameter: ',
      statusMessage: 'Server gave an error: ',
      timeout: 'Your request timed out'
    },

    regExp: {
      required: /\{\$*[A-z0-9]+\}/g,
      optional: /\{\/\$*[A-z0-9]+\}/g,
    },

    className: {
      loading: 'loading',
      error: 'error'
    },

    selector: {
      disabled: '.disabled',
      form: 'form'
    },

    metadata: {
      action: 'action',
      url: 'url'
    }
  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - State
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.state = function (parameters) {
    var
        $allModules = $(this),

        moduleSelector = $allModules.selector || '',

        hasTouch = ('ontouchstart' in document.documentElement),
        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),

        returnedValue
    ;
    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.state.settings, parameters)
              : $.extend({}, $.fn.state.settings),

          error = settings.error,
          metadata = settings.metadata,
          className = settings.className,
          namespace = settings.namespace,
          states = settings.states,
          text = settings.text,

          eventNamespace = '.' + namespace,
          moduleNamespace = namespace + '-module',

          $module = $(this),

          element = this,
          instance = $module.data(moduleNamespace),

          module
      ;
      module = {

        initialize: function () {
          module.verbose('Initializing module');

          // allow module to guess desired state based on element
          if (settings.automatic) {
            module.add.defaults();
          }

          // bind events with delegated events
          if (settings.context && moduleSelector !== '') {
            $(settings.context)
            .on(moduleSelector, 'mouseenter' + eventNamespace,
                module.change.text)
            .on(moduleSelector, 'mouseleave' + eventNamespace,
                module.reset.text)
            .on(moduleSelector, 'click' + eventNamespace, module.toggle.state)
            ;
          }
          else {
            $module
            .on('mouseenter' + eventNamespace, module.change.text)
            .on('mouseleave' + eventNamespace, module.reset.text)
            .on('click' + eventNamespace, module.toggle.state)
            ;
          }
          module.instantiate();
        },

        instantiate: function () {
          module.verbose('Storing instance of module', module);
          instance = module;
          $module
          .data(moduleNamespace, module)
          ;
        },

        destroy: function () {
          module.verbose('Destroying previous module', instance);
          $module
          .off(eventNamespace)
          .removeData(moduleNamespace)
          ;
        },

        refresh: function () {
          module.verbose('Refreshing selector cache');
          $module = $(element);
        },

        add: {
          defaults: function () {
            var
                userStates = parameters && $.isPlainObject(parameters.states)
                    ? parameters.states
                    : {}
            ;
            $.each(settings.defaults, function (type, typeStates) {
              if (module.is[type] !== undefined && module.is[type]()) {
                module.verbose('Adding default states', type, element);
                $.extend(settings.states, typeStates, userStates);
              }
            });
          }
        },

        is: {

          active: function () {
            return $module.hasClass(className.active);
          },
          loading: function () {
            return $module.hasClass(className.loading);
          },
          inactive: function () {
            return !( $module.hasClass(className.active) );
          },
          state: function (state) {
            if (className[state] === undefined) {
              return false;
            }
            return $module.hasClass(className[state]);
          },

          enabled: function () {
            return !( $module.is(settings.filter.active) );
          },
          disabled: function () {
            return ( $module.is(settings.filter.active) );
          },
          textEnabled: function () {
            return !( $module.is(settings.filter.text) );
          },

          // definitions for automatic type detection
          button: function () {
            return $module.is('.button:not(a, .submit)');
          },
          input: function () {
            return $module.is('input');
          },
          progress: function () {
            return $module.is('.ui.progress');
          }
        },

        allow: function (state) {
          module.debug('Now allowing state', state);
          states[state] = true;
        },
        disallow: function (state) {
          module.debug('No longer allowing', state);
          states[state] = false;
        },

        allows: function (state) {
          return states[state] || false;
        },

        enable: function () {
          $module.removeClass(className.disabled);
        },

        disable: function () {
          $module.addClass(className.disabled);
        },

        setState: function (state) {
          if (module.allows(state)) {
            $module.addClass(className[state]);
          }
        },

        removeState: function (state) {
          if (module.allows(state)) {
            $module.removeClass(className[state]);
          }
        },

        toggle: {
          state: function () {
            var
                apiRequest,
                requestCancelled
            ;
            if (module.allows('active') && module.is.enabled()) {
              module.refresh();
              if ($.fn.api !== undefined) {
                apiRequest = $module.api('get request');
                requestCancelled = $module.api('was cancelled');
                if (requestCancelled) {
                  module.debug('API Request cancelled by beforesend');
                  settings.activateTest = function () {
                    return false;
                  };
                  settings.deactivateTest = function () {
                    return false;
                  };
                }
                else if (apiRequest) {
                  module.listenTo(apiRequest);
                  return;
                }
              }
              module.change.state();
            }
          }
        },

        listenTo: function (apiRequest) {
          module.debug('API request detected, waiting for state signal',
              apiRequest);
          if (apiRequest) {
            if (text.loading) {
              module.update.text(text.loading);
            }
            $.when(apiRequest)
            .then(function () {
              if (apiRequest.state() == 'resolved') {
                module.debug('API request succeeded');
                settings.activateTest = function () {
                  return true;
                };
                settings.deactivateTest = function () {
                  return true;
                };
              }
              else {
                module.debug('API request failed');
                settings.activateTest = function () {
                  return false;
                };
                settings.deactivateTest = function () {
                  return false;
                };
              }
              module.change.state();
            })
            ;
          }
        },

        // checks whether active/inactive state can be given
        change: {

          state: function () {
            module.debug('Determining state change direction');
            // inactive to active change
            if (module.is.inactive()) {
              module.activate();
            }
            else {
              module.deactivate();
            }
            if (settings.sync) {
              module.sync();
            }
            settings.onChange.call(element);
          },

          text: function () {
            if (module.is.textEnabled()) {
              if (module.is.disabled()) {
                module.verbose('Changing text to disabled text', text.hover);
                module.update.text(text.disabled);
              }
              else if (module.is.active()) {
                if (text.hover) {
                  module.verbose('Changing text to hover text', text.hover);
                  module.update.text(text.hover);
                }
                else if (text.deactivate) {
                  module.verbose('Changing text to deactivating text',
                      text.deactivate);
                  module.update.text(text.deactivate);
                }
              }
              else {
                if (text.hover) {
                  module.verbose('Changing text to hover text', text.hover);
                  module.update.text(text.hover);
                }
                else if (text.activate) {
                  module.verbose('Changing text to activating text',
                      text.activate);
                  module.update.text(text.activate);
                }
              }
            }
          }

        },

        activate: function () {
          if (settings.activateTest.call(element)) {
            module.debug('Setting state to active');
            $module
            .addClass(className.active)
            ;
            module.update.text(text.active);
            settings.onActivate.call(element);
          }
        },

        deactivate: function () {
          if (settings.deactivateTest.call(element)) {
            module.debug('Setting state to inactive');
            $module
            .removeClass(className.active)
            ;
            module.update.text(text.inactive);
            settings.onDeactivate.call(element);
          }
        },

        sync: function () {
          module.verbose('Syncing other buttons to current state');
          if (module.is.active()) {
            $allModules
            .not($module)
            .state('activate');
          }
          else {
            $allModules
            .not($module)
            .state('deactivate')
            ;
          }
        },

        get: {
          text: function () {
            return (settings.selector.text)
                ? $module.find(settings.selector.text).text()
                : $module.html()
                ;
          },
          textFor: function (state) {
            return text[state] || false;
          }
        },

        flash: {
          text: function (text, duration, callback) {
            var
                previousText = module.get.text()
            ;
            module.debug('Flashing text message', text, duration);
            text = text || settings.text.flash;
            duration = duration || settings.flashDuration;
            callback = callback || function () {
                };
            module.update.text(text);
            setTimeout(function () {
              module.update.text(previousText);
              callback.call(element);
            }, duration);
          }
        },

        reset: {
          // on mouseout sets text to previous value
          text: function () {
            var
                activeText = text.active || $module.data(metadata.storedText),
                inactiveText = text.inactive || $module.data(
                        metadata.storedText)
            ;
            if (module.is.textEnabled()) {
              if (module.is.active() && activeText) {
                module.verbose('Resetting active text', activeText);
                module.update.text(activeText);
              }
              else if (inactiveText) {
                module.verbose('Resetting inactive text', activeText);
                module.update.text(inactiveText);
              }
            }
          }
        },

        update: {
          text: function (text) {
            var
                currentText = module.get.text()
            ;
            if (text && text !== currentText) {
              module.debug('Updating text', text);
              if (settings.selector.text) {
                $module
                .data(metadata.storedText, text)
                .find(settings.selector.text)
                .text(text)
                ;
              }
              else {
                $module
                .data(metadata.storedText, text)
                .html(text)
                ;
              }
            }
            else {
              module.debug('Text is already set, ignoring update', text);
            }
          }
        },

        setting: function (name, value) {
          module.debug('Changing setting', name, value);
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            if ($.isPlainObject(settings[name])) {
              $.extend(true, settings[name], value);
            }
            else {
              settings[name] = value;
            }
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.state.settings = {

    // module info
    name: 'State',

    // debug output
    debug: false,

    // verbose debug output
    verbose: false,

    // namespace for events
    namespace: 'state',

    // debug data includes performance
    performance: true,

    // callback occurs on state change
    onActivate: function () {
    },
    onDeactivate: function () {
    },
    onChange: function () {
    },

    // state test functions
    activateTest: function () {
      return true;
    },
    deactivateTest: function () {
      return true;
    },

    // whether to automatically map default states
    automatic: true,

    // activate / deactivate changes all elements instantiated at same time
    sync: false,

    // default flash text duration, used for temporarily changing text of an element
    flashDuration: 1000,

    // selector filter
    filter: {
      text: '.loading, .disabled',
      active: '.disabled'
    },

    context: false,

    // error
    error: {
      beforeSend: 'The before send function has cancelled state change',
      method: 'The method you called is not defined.'
    },

    // metadata
    metadata: {
      promise: 'promise',
      storedText: 'stored-text'
    },

    // change class on state
    className: {
      active: 'active',
      disabled: 'disabled',
      error: 'error',
      loading: 'loading',
      success: 'success',
      warning: 'warning'
    },

    selector: {
      // selector for text node
      text: false
    },

    defaults: {
      input: {
        disabled: true,
        loading: true,
        active: true
      },
      button: {
        disabled: true,
        loading: true,
        active: true,
      },
      progress: {
        active: true,
        success: true,
        warning: true,
        error: true
      }
    },

    states: {
      active: true,
      disabled: true,
      error: true,
      loading: true,
      success: true,
      warning: true
    },

    text: {
      disabled: false,
      flash: false,
      hover: false,
      active: false,
      inactive: false,
      activate: false,
      deactivate: false
    }

  };

})(jQuery, window, document);

/*!
 * # Semantic UI 2.2.10 - Visibility
 * http://github.com/semantic-org/semantic-ui/
 *
 *
 * Released under the MIT license
 * http://opensource.org/licenses/MIT
 *
 */

;(function ($, window, document, undefined) {

  "use strict";

  window = (typeof window != 'undefined' && window.Math == Math)
      ? window
      : (typeof self != 'undefined' && self.Math == Math)
          ? self
          : Function('return this')()
  ;

  $.fn.visibility = function (parameters) {
    var
        $allModules = $(this),
        moduleSelector = $allModules.selector || '',

        time = new Date().getTime(),
        performance = [],

        query = arguments[0],
        methodInvoked = (typeof query == 'string'),
        queryArguments = [].slice.call(arguments, 1),
        returnedValue,

        moduleCount = $allModules.length,
        loadedCount = 0
    ;

    $allModules
    .each(function () {
      var
          settings = ( $.isPlainObject(parameters) )
              ? $.extend(true, {}, $.fn.visibility.settings, parameters)
              : $.extend({}, $.fn.visibility.settings),

          className = settings.className,
          namespace = settings.namespace,
          error = settings.error,
          metadata = settings.metadata,

          eventNamespace = '.' + namespace,
          moduleNamespace = 'module-' + namespace,

          $window = $(window),

          $module = $(this),
          $context = $(settings.context),

          $placeholder,

          selector = $module.selector || '',
          instance = $module.data(moduleNamespace),

          requestAnimationFrame = window.requestAnimationFrame
              || window.mozRequestAnimationFrame
              || window.webkitRequestAnimationFrame
              || window.msRequestAnimationFrame
              || function (callback) {
                setTimeout(callback, 0);
              },

          element = this,
          disabled = false,

          contextObserver,
          observer,
          module
      ;

      module = {

        initialize: function () {
          module.debug('Initializing', settings);

          module.setup.cache();

          if (module.should.trackChanges()) {

            if (settings.type == 'image') {
              module.setup.image();
            }
            if (settings.type == 'fixed') {
              module.setup.fixed();
            }

            if (settings.observeChanges) {
              module.observeChanges();
            }
            module.bind.events();
          }

          module.save.position();
          if (!module.is.visible()) {
            module.error(error.visible, $module);
          }

          if (settings.initialCheck) {
            module.checkVisibility();
          }
          module.instantiate();
        },

        instantiate: function () {
          module.debug('Storing instance', module);
          $module
          .data(moduleNamespace, module)
          ;
          instance = module;
        },

        destroy: function () {
          module.verbose('Destroying previous module');
          if (observer) {
            observer.disconnect();
          }
          if (contextObserver) {
            contextObserver.disconnect();
          }
          $window
          .off('load' + eventNamespace, module.event.load)
          .off('resize' + eventNamespace, module.event.resize)
          ;
          $context
          .off('scroll' + eventNamespace, module.event.scroll)
          .off('scrollchange' + eventNamespace, module.event.scrollchange)
          ;
          if (settings.type == 'fixed') {
            module.resetFixed();
            module.remove.placeholder();
          }
          $module
          .off(eventNamespace)
          .removeData(moduleNamespace)
          ;
        },

        observeChanges: function () {
          if ('MutationObserver' in window) {
            contextObserver = new MutationObserver(module.event.contextChanged);
            observer = new MutationObserver(module.event.changed);
            contextObserver.observe(document, {
              childList: true,
              subtree: true
            });
            observer.observe(element, {
              childList: true,
              subtree: true
            });
            module.debug('Setting up mutation observer', observer);
          }
        },

        bind: {
          events: function () {
            module.verbose('Binding visibility events to scroll and resize');
            if (settings.refreshOnLoad) {
              $window
              .on('load' + eventNamespace, module.event.load)
              ;
            }
            $window
            .on('resize' + eventNamespace, module.event.resize)
            ;
            // pub/sub pattern
            $context
            .off('scroll' + eventNamespace)
            .on('scroll' + eventNamespace, module.event.scroll)
            .on('scrollchange' + eventNamespace, module.event.scrollchange)
            ;
          }
        },

        event: {
          changed: function (mutations) {
            module.verbose(
                'DOM tree modified, updating visibility calculations');
            module.timer = setTimeout(function () {
              module.verbose('DOM tree modified, updating sticky menu');
              module.refresh();
            }, 100);
          },
          contextChanged: function (mutations) {
            [].forEach.call(mutations, function (mutation) {
              if (mutation.removedNodes) {
                [].forEach.call(mutation.removedNodes, function (node) {
                  if (node == element || $(node).find(element).length > 0) {
                    module.debug(
                        'Element removed from DOM, tearing down events');
                    module.destroy();
                  }
                });
              }
            });
          },
          resize: function () {
            module.debug('Window resized');
            if (settings.refreshOnResize) {
              requestAnimationFrame(module.refresh);
            }
          },
          load: function () {
            module.debug('Page finished loading');
            requestAnimationFrame(module.refresh);
          },
          // publishes scrollchange event on one scroll
          scroll: function () {
            if (settings.throttle) {
              clearTimeout(module.timer);
              module.timer = setTimeout(function () {
                $context.triggerHandler('scrollchange' + eventNamespace,
                    [$context.scrollTop()]);
              }, settings.throttle);
            }
            else {
              requestAnimationFrame(function () {
                $context.triggerHandler('scrollchange' + eventNamespace,
                    [$context.scrollTop()]);
              });
            }
          },
          // subscribes to scrollchange
          scrollchange: function (event, scrollPosition) {
            module.checkVisibility(scrollPosition);
          },
        },

        precache: function (images, callback) {
          if (!(images instanceof Array)) {
            images = [images];
          }
          var
              imagesLength = images.length,
              loadedCounter = 0,
              cache = [],
              cacheImage = document.createElement('img'),
              handleLoad = function () {
                loadedCounter++;
                if (loadedCounter >= images.length) {
                  if ($.isFunction(callback)) {
                    callback();
                  }
                }
              }
          ;
          while (imagesLength--) {
            cacheImage = document.createElement('img');
            cacheImage.onload = handleLoad;
            cacheImage.onerror = handleLoad;
            cacheImage.src = images[imagesLength];
            cache.push(cacheImage);
          }
        },

        enableCallbacks: function () {
          module.debug('Allowing callbacks to occur');
          disabled = false;
        },

        disableCallbacks: function () {
          module.debug('Disabling all callbacks temporarily');
          disabled = true;
        },

        should: {
          trackChanges: function () {
            if (methodInvoked) {
              module.debug('One time query, no need to bind events');
              return false;
            }
            module.debug('Callbacks being attached');
            return true;
          }
        },

        setup: {
          cache: function () {
            module.cache = {
              occurred: {},
              screen: {},
              element: {},
            };
          },
          image: function () {
            var
                src = $module.data(metadata.src)
            ;
            if (src) {
              module.verbose('Lazy loading image', src);
              settings.once = true;
              settings.observeChanges = false;

              // show when top visible
              settings.onOnScreen = function () {
                module.debug('Image on screen', element);
                module.precache(src, function () {
                  module.set.image(src, function () {
                    loadedCount++;
                    if (loadedCount == moduleCount) {
                      settings.onAllLoaded.call(this);
                    }
                    settings.onLoad.call(this);
                  });
                });
              };
            }
          },
          fixed: function () {
            module.debug('Setting up fixed');
            settings.once = false;
            settings.observeChanges = false;
            settings.initialCheck = true;
            settings.refreshOnLoad = true;
            if (!parameters.transition) {
              settings.transition = false;
            }
            module.create.placeholder();
            module.debug('Added placeholder', $placeholder);
            settings.onTopPassed = function () {
              module.debug('Element passed, adding fixed position', $module);
              module.show.placeholder();
              module.set.fixed();
              if (settings.transition) {
                if ($.fn.transition !== undefined) {
                  $module.transition(settings.transition, settings.duration);
                }
              }
            };
            settings.onTopPassedReverse = function () {
              module.debug('Element returned to position, removing fixed',
                  $module);
              module.hide.placeholder();
              module.remove.fixed();
            };
          }
        },

        create: {
          placeholder: function () {
            module.verbose('Creating fixed position placeholder');
            $placeholder = $module
            .clone(false)
            .css('display', 'none')
            .addClass(className.placeholder)
            .insertAfter($module)
            ;
          }
        },

        show: {
          placeholder: function () {
            module.verbose('Showing placeholder');
            $placeholder
            .css('display', 'block')
            .css('visibility', 'hidden')
            ;
          }
        },
        hide: {
          placeholder: function () {
            module.verbose('Hiding placeholder');
            $placeholder
            .css('display', 'none')
            .css('visibility', '')
            ;
          }
        },

        set: {
          fixed: function () {
            module.verbose('Setting element to fixed position');
            $module
            .addClass(className.fixed)
            .css({
              position: 'fixed',
              top: settings.offset + 'px',
              left: 'auto',
              zIndex: settings.zIndex
            })
            ;
            settings.onFixed.call(element);
          },
          image: function (src, callback) {
            $module
            .attr('src', src)
            ;
            if (settings.transition) {
              if ($.fn.transition !== undefined) {
                if ($module.hasClass(className.visible)) {
                  module.debug(
                      'Transition already occurred on this image, skipping animation');
                  return;
                }
                $module.transition(settings.transition, settings.duration,
                    callback);
              }
              else {
                $module.fadeIn(settings.duration, callback);
              }
            }
            else {
              $module.show();
            }
          }
        },

        is: {
          onScreen: function () {
            var
                calculations = module.get.elementCalculations()
            ;
            return calculations.onScreen;
          },
          offScreen: function () {
            var
                calculations = module.get.elementCalculations()
            ;
            return calculations.offScreen;
          },
          visible: function () {
            if (module.cache && module.cache.element) {
              return !(module.cache.element.width === 0
              && module.cache.element.offset.top === 0);
            }
            return false;
          },
          verticallyScrollableContext: function () {
            var
                overflowY = ($context.get(0) !== window)
                    ? $context.css('overflow-y')
                    : false
            ;
            return (overflowY == 'auto' || overflowY == 'scroll');
          },
          horizontallyScrollableContext: function () {
            var
                overflowX = ($context.get(0) !== window)
                    ? $context.css('overflow-x')
                    : false
            ;
            return (overflowX == 'auto' || overflowX == 'scroll');
          }
        },

        refresh: function () {
          module.debug('Refreshing constants (width/height)');
          if (settings.type == 'fixed') {
            module.resetFixed();
          }
          module.reset();
          module.save.position();
          if (settings.checkOnRefresh) {
            module.checkVisibility();
          }
          settings.onRefresh.call(element);
        },

        resetFixed: function () {
          module.remove.fixed();
          module.remove.occurred();
        },

        reset: function () {
          module.verbose('Resetting all cached values');
          if ($.isPlainObject(module.cache)) {
            module.cache.screen = {};
            module.cache.element = {};
          }
        },

        checkVisibility: function (scroll) {
          module.verbose('Checking visibility of element',
              module.cache.element);

          if (!disabled && module.is.visible()) {

            // save scroll position
            module.save.scroll(scroll);

            // update calculations derived from scroll
            module.save.calculations();

            // percentage
            module.passed();

            // reverse (must be first)
            module.passingReverse();
            module.topVisibleReverse();
            module.bottomVisibleReverse();
            module.topPassedReverse();
            module.bottomPassedReverse();

            // one time
            module.onScreen();
            module.offScreen();
            module.passing();
            module.topVisible();
            module.bottomVisible();
            module.topPassed();
            module.bottomPassed();

            // on update callback
            if (settings.onUpdate) {
              settings.onUpdate.call(element, module.get.elementCalculations());
            }
          }
        },

        passed: function (amount, newCallback) {
          var
              calculations = module.get.elementCalculations(),
              amountInPixels
          ;
          // assign callback
          if (amount && newCallback) {
            settings.onPassed[amount] = newCallback;
          }
          else if (amount !== undefined) {
            return (module.get.pixelsPassed(amount)
            > calculations.pixelsPassed);
          }
          else if (calculations.passing) {
            $.each(settings.onPassed, function (amount, callback) {
              if (calculations.bottomVisible || calculations.pixelsPassed
                  > module.get.pixelsPassed(amount)) {
                module.execute(callback, amount);
              }
              else if (!settings.once) {
                module.remove.occurred(callback);
              }
            });
          }
        },

        onScreen: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onOnScreen,
              callbackName = 'onScreen'
          ;
          if (newCallback) {
            module.debug('Adding callback for onScreen', newCallback);
            settings.onOnScreen = newCallback;
          }
          if (calculations.onScreen) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback !== undefined) {
            return calculations.onOnScreen;
          }
        },

        offScreen: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onOffScreen,
              callbackName = 'offScreen'
          ;
          if (newCallback) {
            module.debug('Adding callback for offScreen', newCallback);
            settings.onOffScreen = newCallback;
          }
          if (calculations.offScreen) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback !== undefined) {
            return calculations.onOffScreen;
          }
        },

        passing: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onPassing,
              callbackName = 'passing'
          ;
          if (newCallback) {
            module.debug('Adding callback for passing', newCallback);
            settings.onPassing = newCallback;
          }
          if (calculations.passing) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback !== undefined) {
            return calculations.passing;
          }
        },

        topVisible: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onTopVisible,
              callbackName = 'topVisible'
          ;
          if (newCallback) {
            module.debug('Adding callback for top visible', newCallback);
            settings.onTopVisible = newCallback;
          }
          if (calculations.topVisible) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return calculations.topVisible;
          }
        },

        bottomVisible: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onBottomVisible,
              callbackName = 'bottomVisible'
          ;
          if (newCallback) {
            module.debug('Adding callback for bottom visible', newCallback);
            settings.onBottomVisible = newCallback;
          }
          if (calculations.bottomVisible) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return calculations.bottomVisible;
          }
        },

        topPassed: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onTopPassed,
              callbackName = 'topPassed'
          ;
          if (newCallback) {
            module.debug('Adding callback for top passed', newCallback);
            settings.onTopPassed = newCallback;
          }
          if (calculations.topPassed) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return calculations.topPassed;
          }
        },

        bottomPassed: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onBottomPassed,
              callbackName = 'bottomPassed'
          ;
          if (newCallback) {
            module.debug('Adding callback for bottom passed', newCallback);
            settings.onBottomPassed = newCallback;
          }
          if (calculations.bottomPassed) {
            module.execute(callback, callbackName);
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return calculations.bottomPassed;
          }
        },

        passingReverse: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onPassingReverse,
              callbackName = 'passingReverse'
          ;
          if (newCallback) {
            module.debug('Adding callback for passing reverse', newCallback);
            settings.onPassingReverse = newCallback;
          }
          if (!calculations.passing) {
            if (module.get.occurred('passing')) {
              module.execute(callback, callbackName);
            }
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback !== undefined) {
            return !calculations.passing;
          }
        },

        topVisibleReverse: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onTopVisibleReverse,
              callbackName = 'topVisibleReverse'
          ;
          if (newCallback) {
            module.debug('Adding callback for top visible reverse',
                newCallback);
            settings.onTopVisibleReverse = newCallback;
          }
          if (!calculations.topVisible) {
            if (module.get.occurred('topVisible')) {
              module.execute(callback, callbackName);
            }
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return !calculations.topVisible;
          }
        },

        bottomVisibleReverse: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onBottomVisibleReverse,
              callbackName = 'bottomVisibleReverse'
          ;
          if (newCallback) {
            module.debug('Adding callback for bottom visible reverse',
                newCallback);
            settings.onBottomVisibleReverse = newCallback;
          }
          if (!calculations.bottomVisible) {
            if (module.get.occurred('bottomVisible')) {
              module.execute(callback, callbackName);
            }
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return !calculations.bottomVisible;
          }
        },

        topPassedReverse: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onTopPassedReverse,
              callbackName = 'topPassedReverse'
          ;
          if (newCallback) {
            module.debug('Adding callback for top passed reverse', newCallback);
            settings.onTopPassedReverse = newCallback;
          }
          if (!calculations.topPassed) {
            if (module.get.occurred('topPassed')) {
              module.execute(callback, callbackName);
            }
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return !calculations.onTopPassed;
          }
        },

        bottomPassedReverse: function (newCallback) {
          var
              calculations = module.get.elementCalculations(),
              callback = newCallback || settings.onBottomPassedReverse,
              callbackName = 'bottomPassedReverse'
          ;
          if (newCallback) {
            module.debug('Adding callback for bottom passed reverse',
                newCallback);
            settings.onBottomPassedReverse = newCallback;
          }
          if (!calculations.bottomPassed) {
            if (module.get.occurred('bottomPassed')) {
              module.execute(callback, callbackName);
            }
          }
          else if (!settings.once) {
            module.remove.occurred(callbackName);
          }
          if (newCallback === undefined) {
            return !calculations.bottomPassed;
          }
        },

        execute: function (callback, callbackName) {
          var
              calculations = module.get.elementCalculations(),
              screen = module.get.screenCalculations()
          ;
          callback = callback || false;
          if (callback) {
            if (settings.continuous) {
              module.debug('Callback being called continuously', callbackName,
                  calculations);
              callback.call(element, calculations, screen);
            }
            else if (!module.get.occurred(callbackName)) {
              module.debug('Conditions met', callbackName, calculations);
              callback.call(element, calculations, screen);
            }
          }
          module.save.occurred(callbackName);
        },

        remove: {
          fixed: function () {
            module.debug('Removing fixed position');
            $module
            .removeClass(className.fixed)
            .css({
              position: '',
              top: '',
              left: '',
              zIndex: ''
            })
            ;
            settings.onUnfixed.call(element);
          },
          placeholder: function () {
            module.debug('Removing placeholder content');
            if ($placeholder) {
              $placeholder.remove();
            }
          },
          occurred: function (callback) {
            if (callback) {
              var
                  occurred = module.cache.occurred
              ;
              if (occurred[callback] !== undefined && occurred[callback]
                  === true) {
                module.debug('Callback can now be called again', callback);
                module.cache.occurred[callback] = false;
              }
            }
            else {
              module.cache.occurred = {};
            }
          }
        },

        save: {
          calculations: function () {
            module.verbose(
                'Saving all calculations necessary to determine positioning');
            module.save.direction();
            module.save.screenCalculations();
            module.save.elementCalculations();
          },
          occurred: function (callback) {
            if (callback) {
              if (module.cache.occurred[callback] === undefined
                  || (module.cache.occurred[callback] !== true)) {
                module.verbose('Saving callback occurred', callback);
                module.cache.occurred[callback] = true;
              }
            }
          },
          scroll: function (scrollPosition) {
            scrollPosition = scrollPosition + settings.offset
                || $context.scrollTop() + settings.offset;
            module.cache.scroll = scrollPosition;
          },
          direction: function () {
            var
                scroll = module.get.scroll(),
                lastScroll = module.get.lastScroll(),
                direction
            ;
            if (scroll > lastScroll && lastScroll) {
              direction = 'down';
            }
            else if (scroll < lastScroll && lastScroll) {
              direction = 'up';
            }
            else {
              direction = 'static';
            }
            module.cache.direction = direction;
            return module.cache.direction;
          },
          elementPosition: function () {
            var
                element = module.cache.element,
                screen = module.get.screenSize()
            ;
            module.verbose('Saving element position');
            // (quicker than $.extend)
            element.fits = (element.height < screen.height);
            element.offset = $module.offset();
            element.width = $module.outerWidth();
            element.height = $module.outerHeight();
            // compensate for scroll in context
            if (module.is.verticallyScrollableContext()) {
              element.offset.top += $context.scrollTop()
                  - $context.offset().top;
            }
            if (module.is.horizontallyScrollableContext()) {
              element.offset.left += $context.scrollLeft
                  - $context.offset().left;
            }
            // store
            module.cache.element = element;
            return element;
          },
          elementCalculations: function () {
            var
                screen = module.get.screenCalculations(),
                element = module.get.elementPosition()
            ;
            // offset
            if (settings.includeMargin) {
              element.margin = {};
              element.margin.top = parseInt($module.css('margin-top'), 10);
              element.margin.bottom = parseInt($module.css('margin-bottom'),
                  10);
              element.top = element.offset.top - element.margin.top;
              element.bottom = element.offset.top + element.height
                  + element.margin.bottom;
            }
            else {
              element.top = element.offset.top;
              element.bottom = element.offset.top + element.height;
            }

            // visibility
            element.topPassed = (screen.top >= element.top);
            element.bottomPassed = (screen.top >= element.bottom);
            element.topVisible = (screen.bottom >= element.top)
                && !element.bottomPassed;
            element.bottomVisible = (screen.bottom >= element.bottom)
                && !element.topPassed;
            element.pixelsPassed = 0;
            element.percentagePassed = 0;

            // meta calculations
            element.onScreen = (element.topVisible && !element.bottomPassed);
            element.passing = (element.topPassed && !element.bottomPassed);
            element.offScreen = (!element.onScreen);

            // passing calculations
            if (element.passing) {
              element.pixelsPassed = (screen.top - element.top);
              element.percentagePassed = (screen.top - element.top)
                  / element.height;
            }
            module.cache.element = element;
            module.verbose('Updated element calculations', element);
            return element;
          },
          screenCalculations: function () {
            var
                scroll = module.get.scroll()
            ;
            module.save.direction();
            module.cache.screen.top = scroll;
            module.cache.screen.bottom = scroll + module.cache.screen.height;
            return module.cache.screen;
          },
          screenSize: function () {
            module.verbose('Saving window position');
            module.cache.screen = {
              height: $context.height()
            };
          },
          position: function () {
            module.save.screenSize();
            module.save.elementPosition();
          }
        },

        get: {
          pixelsPassed: function (amount) {
            var
                element = module.get.elementCalculations()
            ;
            if (amount.search('%') > -1) {
              return ( element.height * (parseInt(amount, 10) / 100) );
            }
            return parseInt(amount, 10);
          },
          occurred: function (callback) {
            return (module.cache.occurred !== undefined)
                ? module.cache.occurred[callback] || false
                : false
                ;
          },
          direction: function () {
            if (module.cache.direction === undefined) {
              module.save.direction();
            }
            return module.cache.direction;
          },
          elementPosition: function () {
            if (module.cache.element === undefined) {
              module.save.elementPosition();
            }
            return module.cache.element;
          },
          elementCalculations: function () {
            if (module.cache.element === undefined) {
              module.save.elementCalculations();
            }
            return module.cache.element;
          },
          screenCalculations: function () {
            if (module.cache.screen === undefined) {
              module.save.screenCalculations();
            }
            return module.cache.screen;
          },
          screenSize: function () {
            if (module.cache.screen === undefined) {
              module.save.screenSize();
            }
            return module.cache.screen;
          },
          scroll: function () {
            if (module.cache.scroll === undefined) {
              module.save.scroll();
            }
            return module.cache.scroll;
          },
          lastScroll: function () {
            if (module.cache.screen === undefined) {
              module.debug('First scroll event, no last scroll could be found');
              return false;
            }
            return module.cache.screen.top;
          }
        },

        setting: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, settings, name);
          }
          else if (value !== undefined) {
            settings[name] = value;
          }
          else {
            return settings[name];
          }
        },
        internal: function (name, value) {
          if ($.isPlainObject(name)) {
            $.extend(true, module, name);
          }
          else if (value !== undefined) {
            module[name] = value;
          }
          else {
            return module[name];
          }
        },
        debug: function () {
          if (!settings.silent && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.debug = Function.prototype.bind.call(console.info, console,
                  settings.name + ':');
              module.debug.apply(console, arguments);
            }
          }
        },
        verbose: function () {
          if (!settings.silent && settings.verbose && settings.debug) {
            if (settings.performance) {
              module.performance.log(arguments);
            }
            else {
              module.verbose = Function.prototype.bind.call(console.info,
                  console, settings.name + ':');
              module.verbose.apply(console, arguments);
            }
          }
        },
        error: function () {
          if (!settings.silent) {
            module.error = Function.prototype.bind.call(console.error, console,
                settings.name + ':');
            module.error.apply(console, arguments);
          }
        },
        performance: {
          log: function (message) {
            var
                currentTime,
                executionTime,
                previousTime
            ;
            if (settings.performance) {
              currentTime = new Date().getTime();
              previousTime = time || currentTime;
              executionTime = currentTime - previousTime;
              time = currentTime;
              performance.push({
                'Name': message[0],
                'Arguments': [].slice.call(message, 1) || '',
                'Element': element,
                'Execution Time': executionTime
              });
            }
            clearTimeout(module.performance.timer);
            module.performance.timer = setTimeout(module.performance.display,
                500);
          },
          display: function () {
            var
                title = settings.name + ':',
                totalTime = 0
            ;
            time = false;
            clearTimeout(module.performance.timer);
            $.each(performance, function (index, data) {
              totalTime += data['Execution Time'];
            });
            title += ' ' + totalTime + 'ms';
            if (moduleSelector) {
              title += ' \'' + moduleSelector + '\'';
            }
            if ((console.group !== undefined || console.table !== undefined)
                && performance.length > 0) {
              console.groupCollapsed(title);
              if (console.table) {
                console.table(performance);
              }
              else {
                $.each(performance, function (index, data) {
                  console.log(
                      data['Name'] + ': ' + data['Execution Time'] + 'ms');
                });
              }
              console.groupEnd();
            }
            performance = [];
          }
        },
        invoke: function (query, passedArguments, context) {
          var
              object = instance,
              maxDepth,
              found,
              response
          ;
          passedArguments = passedArguments || queryArguments;
          context = element || context;
          if (typeof query == 'string' && object !== undefined) {
            query = query.split(/[\. ]/);
            maxDepth = query.length - 1;
            $.each(query, function (depth, value) {
              var camelCaseValue = (depth != maxDepth)
                  ? value + query[depth + 1].charAt(0).toUpperCase()
                  + query[depth + 1].slice(1)
                  : query
              ;
              if ($.isPlainObject(object[camelCaseValue]) && (depth
                  != maxDepth)) {
                object = object[camelCaseValue];
              }
              else if (object[camelCaseValue] !== undefined) {
                found = object[camelCaseValue];
                return false;
              }
              else if ($.isPlainObject(object[value]) && (depth != maxDepth)) {
                object = object[value];
              }
              else if (object[value] !== undefined) {
                found = object[value];
                return false;
              }
              else {
                module.error(error.method, query);
                return false;
              }
            });
          }
          if ($.isFunction(found)) {
            response = found.apply(context, passedArguments);
          }
          else if (found !== undefined) {
            response = found;
          }
          if ($.isArray(returnedValue)) {
            returnedValue.push(response);
          }
          else if (returnedValue !== undefined) {
            returnedValue = [returnedValue, response];
          }
          else if (response !== undefined) {
            returnedValue = response;
          }
          return found;
        }
      };

      if (methodInvoked) {
        if (instance === undefined) {
          module.initialize();
        }
        instance.save.scroll();
        instance.save.calculations();
        module.invoke(query);
      }
      else {
        if (instance !== undefined) {
          instance.invoke('destroy');
        }
        module.initialize();
      }
    })
    ;

    return (returnedValue !== undefined)
        ? returnedValue
        : this
        ;
  };

  $.fn.visibility.settings = {

    name: 'Visibility',
    namespace: 'visibility',

    debug: false,
    verbose: false,
    performance: true,

    // whether to use mutation observers to follow changes
    observeChanges: true,

    // check position immediately on init
    initialCheck: true,

    // whether to refresh calculations after all page images load
    refreshOnLoad: true,

    // whether to refresh calculations after page resize event
    refreshOnResize: true,

    // should call callbacks on refresh event (resize, etc)
    checkOnRefresh: true,

    // callback should only occur one time
    once: true,

    // callback should fire continuously whe evaluates to true
    continuous: false,

    // offset to use with scroll top
    offset: 0,

    // whether to include margin in elements position
    includeMargin: false,

    // scroll context for visibility checks
    context: window,

    // visibility check delay in ms (defaults to animationFrame)
    throttle: false,

    // special visibility type (image, fixed)
    type: false,

    // z-index to use with visibility 'fixed'
    zIndex: '10',

    // image only animation settings
    transition: 'fade in',
    duration: 1000,

    // array of callbacks for percentage
    onPassed: {},

    // standard callbacks
    onOnScreen: false,
    onOffScreen: false,
    onPassing: false,
    onTopVisible: false,
    onBottomVisible: false,
    onTopPassed: false,
    onBottomPassed: false,

    // reverse callbacks
    onPassingReverse: false,
    onTopVisibleReverse: false,
    onBottomVisibleReverse: false,
    onTopPassedReverse: false,
    onBottomPassedReverse: false,

    // special callbacks for image
    onLoad: function () {
    },
    onAllLoaded: function () {
    },

    // special callbacks for fixed position
    onFixed: function () {
    },
    onUnfixed: function () {
    },

    // utility callbacks
    onUpdate: false, // disabled by default for performance
    onRefresh: function () {
    },

    metadata: {
      src: 'src'
    },

    className: {
      fixed: 'fixed',
      placeholder: 'placeholder',
      visible: 'visible'
    },

    error: {
      method: 'The method you called is not defined.',
      visible: 'Element is hidden, you must call refresh after element becomes visible'
    }

  };

})(jQuery, window, document);
